View Javadoc
1   /* Generated By:JJTree&JavaCC: Do not edit this line. PLSQLParser.java */
2   /* Copyright (C) 2002 Albert Tumanov
3   
4   This library is free software; you can redistribute it and/or
5   modify it under the terms of the GNU Lesser General Public
6   License as published by the Free Software Foundation; either
7   version 2.1 of the License, or (at your option) any later version.
8   
9   This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13  
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, write to the Free Software
16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  
18  */
19  
20  package net.sourceforge.pmd.lang.plsql.ast;
21  
22  import java.io.*;
23  import net.sourceforge.pmd.lang.ast.Node;
24  import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25  import net.sourceforge.pmd.lang.ast.TokenMgrError;
26  
27  public class PLSQLParser/*@bgen(jjtree)*/implements PLSQLParserTreeConstants, PLSQLParserConstants {/*@bgen(jjtree)*/
28    protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29    /**
30     * main method, for testing only.
31     * @param args
32     */
33    public static void main(String[] args)
34        throws ParseException {
35  
36      PLSQLParser parser = new PLSQLParser(System.in);
37      PLSQLNode node = parser.Input();
38  
39      String s;
40      s = "qwerty";
41  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
42      s = "\u005c"qwerty\u005c"";
43  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
44      s = "\u005c"qwerty\u005c".uiop";
45  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
46      s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
48    }
49  
50    /**
51     Return canonical version of the Oracle
52    */
53    public static String canonicalName(String name)
54    {
55      StringBuilder s =  null ;
56  
57  
58      if (null == name) {
59        return name;
60      }
61      else if (-1 == name.indexOf('"') )
62      {
63        name = name.toUpperCase();
64        s = new StringBuilder(name.trim());
65      }
66      else
67      {
68        StringBuilder oldString = new StringBuilder( name.trim().length());
69        s = new StringBuilder(name.trim());
70        boolean quotedCharacter = false ;
71        for (int i=0; i<oldString.length(); i++) {
72          if (oldString.charAt(i) == '"')
73          {
74  
75            oldString.deleteCharAt(i);
76            i--;
77  
78            //Toggle whether following characters are quoted or not
79            quotedCharacter = !quotedCharacter ;
80          }
81          else
82          {
83            s.append( quotedCharacter
84                      ? s.charAt(i)
85                      : Character.toUpperCase(s.charAt(i))
86                    );
87          }
88        }
89      }
90      return s.toString();
91    }
92  
93  /**
94   * 2006-05-22 - Matthias Hendler - Added parsing of triggers and global functions/procedures
95   *                                 Refactored printing of custom tags into the XML/DOM.
96   *                                 Custom tags are language independent. Reserved tags are linked
97   *                                 to the documented language like RETURN, PARAM and THROWS.
98   */
99  
100 /**
101  * 2006-05-22 - Matthias Hendler - added globalBody()
102  */
103   final public ASTInput Input() throws ParseException {
104                     /*@bgen(jjtree) Input */
105   ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106   boolean jjtc000 = true;
107   jjtree.openNodeScope(jjtn000);
108     try {
109       label_1:
110       while (true) {
111         switch (jj_nt.kind) {
112         case 2:
113         case 3:
114         case 21:
115         case ALTER:
116         case BEGIN:
117         case COLUMN:
118         case COMMENT:
119         case COMMIT:
120         case CONNECT:
121         case CREATE:
122         case DECLARE:
123         case DELETE:
124         case DROP:
125         case EXECUTE:
126         case EXIT:
127         case FUNCTION:
128         case GRANT:
129         case INSERT:
130         case LOCK:
131         case MERGE:
132         case PACKAGE:
133         case PROMPT:
134         case PROCEDURE:
135         case RENAME:
136         case REVOKE:
137         case ROLLBACK:
138         case SAVEPOINT:
139         case SELECT:
140         case SET:
141         case START:
142         case TRIGGER:
143         case TYPE:
144         case SHOW:
145         case SPOOL:
146         case UPDATE:
147         case WITH:
148         case ANALYZE:
149         case ASSOCIATE:
150         case AUDIT:
151         case DDL:
152         case DISASSOCIATE:
153         case NOAUDIT:
154         case TRUNCATE:
155         case ACCEPT:
156         case COPY:
157         case DEFINE:
158         case DISCONNECT:
159         case HOST:
160         case PRINT:
161         case QUIT:
162         case REMARK:
163         case UNDEFINE:
164         case VARIABLE:
165         case WHENEVER:
166         case IDENTIFIER:
167           ;
168           break;
169         default:
170           jj_la1[0] = jj_gen;
171           break label_1;
172         }
173         if (jj_2_1(7)) {
174           PackageSpecification();
175         } else if (jj_2_2(7)) {
176           PackageBody();
177         } else if (jj_2_3(6)) {
178           TypeSpecification();
179         } else if (jj_2_4(6)) {
180           Table();
181         } else if (jj_2_5(6)) {
182           View();
183         } else if (jj_2_6(6)) {
184           TriggerUnit();
185         } else if (jj_2_7(6)) {
186           AlterTrigger();
187         } else if (jj_2_8(6)) {
188           Synonym();
189         } else if (jj_2_9(6)) {
190           Directory();
191         } else if (jj_2_10(6)) {
192           DatabaseLink();
193         } else if (jj_2_11(6)) {
194           Global();
195         } else if (jj_2_12(6)) {
196           DDLCommand();
197         } else if (jj_2_13(2)) {
198           SqlPlusCommand();
199         } else {
200           switch (jj_nt.kind) {
201           case COMMIT:
202           case DELETE:
203           case INSERT:
204           case LOCK:
205           case MERGE:
206           case ROLLBACK:
207           case SAVEPOINT:
208           case SELECT:
209           case UPDATE:
210           case WITH:
211             switch (jj_nt.kind) {
212             case SELECT:
213               jj_consume_token(SELECT);
214               break;
215             case UPDATE:
216               jj_consume_token(UPDATE);
217               break;
218             case INSERT:
219               jj_consume_token(INSERT);
220               break;
221             case DELETE:
222               jj_consume_token(DELETE);
223               break;
224             case COMMIT:
225               jj_consume_token(COMMIT);
226               break;
227             case ROLLBACK:
228               jj_consume_token(ROLLBACK);
229               break;
230             case SAVEPOINT:
231               jj_consume_token(SAVEPOINT);
232               break;
233             case LOCK:
234               jj_consume_token(LOCK);
235               jj_consume_token(TABLE);
236               break;
237             case MERGE:
238               jj_consume_token(MERGE);
239               break;
240             case WITH:
241               jj_consume_token(WITH);
242               break;
243             default:
244               jj_la1[1] = jj_gen;
245               jj_consume_token(-1);
246               throw new ParseException();
247             }
248             SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249             break;
250           default:
251             jj_la1[2] = jj_gen;
252             jj_consume_token(-1);
253             throw new ParseException();
254           }
255         }
256         label_2:
257         while (true) {
258           switch (jj_nt.kind) {
259           case 1:
260             ;
261             break;
262           default:
263             jj_la1[3] = jj_gen;
264             break label_2;
265           }
266           jj_consume_token(1);
267         }
268       }
269       jj_consume_token(0);
270         jjtree.closeNodeScope(jjtn000, true);
271         jjtc000 = false;
272         {if (true) return jjtn000 ;}
273     } catch (Throwable jjte000) {
274           if (jjtc000) {
275             jjtree.clearNodeScope(jjtn000);
276             jjtc000 = false;
277           } else {
278             jjtree.popNode();
279           }
280           if (jjte000 instanceof RuntimeException) {
281             {if (true) throw (RuntimeException)jjte000;}
282           }
283           if (jjte000 instanceof ParseException) {
284             {if (true) throw (ParseException)jjte000;}
285           }
286           {if (true) throw (Error)jjte000;}
287     } finally {
288           if (jjtc000) {
289             jjtree.closeNodeScope(jjtn000, true);
290           }
291     }
292     throw new Error("Missing return statement in function");
293   }
294 
295   final public ASTDDLCommand DDLCommand() throws ParseException {
296  /*@bgen(jjtree) DDLCommand */
297  ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298  boolean jjtc000 = true;
299  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300     try {
301       simpleNode = DDLEvent();
302       SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303     jjtree.closeNodeScope(jjtn000, true);
304     jjtc000 = false;
305     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
306     } catch (Throwable jjte000) {
307     if (jjtc000) {
308       jjtree.clearNodeScope(jjtn000);
309       jjtc000 = false;
310     } else {
311       jjtree.popNode();
312     }
313     if (jjte000 instanceof RuntimeException) {
314       {if (true) throw (RuntimeException)jjte000;}
315     }
316     if (jjte000 instanceof ParseException) {
317       {if (true) throw (ParseException)jjte000;}
318     }
319     {if (true) throw (Error)jjte000;}
320     } finally {
321     if (jjtc000) {
322       jjtree.closeNodeScope(jjtn000, true);
323     }
324     }
325     throw new Error("Missing return statement in function");
326   }
327 
328   final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329  /*@bgen(jjtree) SqlPlusCommand */
330  ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331  boolean jjtc000 = true;
332  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333     try {
334       switch (jj_nt.kind) {
335       case 2:
336         jj_consume_token(2);
337         break;
338       case ACCEPT:
339         jj_consume_token(ACCEPT);
340         break;
341       case COLUMN:
342         jj_consume_token(COLUMN);
343         break;
344       case CONNECT:
345         jj_consume_token(CONNECT);
346         break;
347       case COPY:
348         jj_consume_token(COPY);
349         break;
350       case DEFINE:
351         jj_consume_token(DEFINE);
352         break;
353       case DISCONNECT:
354         jj_consume_token(DISCONNECT);
355         break;
356       case EXECUTE:
357         jj_consume_token(EXECUTE);
358         break;
359       case EXIT:
360         jj_consume_token(EXIT);
361         break;
362       case HOST:
363         jj_consume_token(HOST);
364         break;
365       case PRINT:
366         jj_consume_token(PRINT);
367         break;
368       case PROMPT:
369         jj_consume_token(PROMPT);
370         break;
371       case QUIT:
372         jj_consume_token(QUIT);
373         break;
374       case REMARK:
375         jj_consume_token(REMARK);
376         break;
377       case SET:
378         jj_consume_token(SET);
379         break;
380       case SHOW:
381         jj_consume_token(SHOW);
382         break;
383       case SPOOL:
384         jj_consume_token(SPOOL);
385         break;
386       case START:
387         jj_consume_token(START);
388         break;
389       case UNDEFINE:
390         jj_consume_token(UNDEFINE);
391         break;
392       case VARIABLE:
393         jj_consume_token(VARIABLE);
394         break;
395       case WHENEVER:
396         jj_consume_token(WHENEVER);
397         break;
398       case COMMENT:
399         jj_consume_token(COMMENT);
400         break;
401       case GRANT:
402         jj_consume_token(GRANT);
403         break;
404       case REVOKE:
405         jj_consume_token(REVOKE);
406         break;
407       case DROP:
408         jj_consume_token(DROP);
409         break;
410       case IDENTIFIER:
411         jj_consume_token(IDENTIFIER);
412         break;
413       case 3:
414         jj_consume_token(3);
415         jj_consume_token(ATTACH);
416         break;
417       default:
418         jj_la1[4] = jj_gen;
419         jj_consume_token(-1);
420         throw new ParseException();
421       }
422     sb.append(token.image) ; sb.append(" ...") ;
423       Skip2NextTokenOccurrence(EOL);
424     jjtree.closeNodeScope(jjtn000, true);
425     jjtc000 = false;
426     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
427     } catch (Throwable jjte000) {
428     if (jjtc000) {
429       jjtree.clearNodeScope(jjtn000);
430       jjtc000 = false;
431     } else {
432       jjtree.popNode();
433     }
434     if (jjte000 instanceof RuntimeException) {
435       {if (true) throw (RuntimeException)jjte000;}
436     }
437     if (jjte000 instanceof ParseException) {
438       {if (true) throw (ParseException)jjte000;}
439     }
440     {if (true) throw (Error)jjte000;}
441     } finally {
442     if (jjtc000) {
443       jjtree.closeNodeScope(jjtn000, true);
444     }
445     }
446     throw new Error("Missing return statement in function");
447   }
448 
449 /*
450 SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
451 void attachLibrary() :
452 {}
453 {
454 	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
455 }
456 */
457 
458 /**
459  * All global definitions of triggers, functions and procedures are evaluated here.
460  * Every occurence goes under a new PACKAGE-Node in the XML document.
461  * This happens, cause a global "block" does not have a definied start and end token 
462  * like a package specification or a package body.
463  * Thats why every construct is handled like a new part of the global package.
464  * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
465  * and slow down the whole parsing.
466  * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
467  * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
468  * choose the correct way on a given base. So we can't negate it easily.
469  * On the other hand I could also hold the global state in a global variable. 
470  * But this does not seems the correct way to solve the problem, I think.
471  *
472  * 2006-05-17 - Matthias Hendler - added
473  */
474   final public ASTGlobal Global() throws ParseException {
475  /*@bgen(jjtree) Global */
476   ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477   boolean jjtc000 = true;
478   jjtree.openNodeScope(jjtn000);
479     try {
480       if (jj_2_14(2147483647)) {
481         label_3:
482         while (true) {
483           switch (jj_nt.kind) {
484           case 21:
485             ;
486             break;
487           default:
488             jj_la1[5] = jj_gen;
489             break label_3;
490           }
491           Label();
492         }
493         Block();
494         jj_consume_token(4);
495       } else if (jj_2_15(4)) {
496         ProgramUnit();
497       } else {
498         jj_consume_token(-1);
499         throw new ParseException();
500       }
501         jjtree.closeNodeScope(jjtn000, true);
502         jjtc000 = false;
503         {if (true) return jjtn000 ;}
504     } catch (Throwable jjte000) {
505           if (jjtc000) {
506             jjtree.clearNodeScope(jjtn000);
507             jjtc000 = false;
508           } else {
509             jjtree.popNode();
510           }
511           if (jjte000 instanceof RuntimeException) {
512             {if (true) throw (RuntimeException)jjte000;}
513           }
514           if (jjte000 instanceof ParseException) {
515             {if (true) throw (ParseException)jjte000;}
516           }
517           {if (true) throw (Error)jjte000;}
518     } finally {
519           if (jjtc000) {
520             jjtree.closeNodeScope(jjtn000, true);
521           }
522     }
523     throw new Error("Missing return statement in function");
524   }
525 
526   final public ASTBlock Block() throws ParseException {
527  /*@bgen(jjtree) Block */
528   ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529   boolean jjtc000 = true;
530   jjtree.openNodeScope(jjtn000);
531     try {
532       switch (jj_nt.kind) {
533       case DECLARE:
534         jj_consume_token(DECLARE);
535         DeclarativeSection();
536         break;
537       default:
538         jj_la1[6] = jj_gen;
539         ;
540       }
541       jj_consume_token(BEGIN);
542       label_4:
543       while (true) {
544         switch (jj_nt.kind) {
545         case 5:
546         case 16:
547         case 17:
548         case 21:
549         case REPLACE:
550         case DEFINER:
551         case CURRENT_USER:
552         case LANGUAGE:
553         case INLINE:
554         case ADD:
555         case AGGREGATE:
556         case ARRAY:
557         case AT:
558         case ATTRIBUTE:
559         case AUTHID:
560         case BEGIN:
561         case BODY:
562         case BULK:
563         case BYTE:
564         case CASCADE:
565         case CASE:
566         case CLOSE:
567         case COALESCE:
568         case COLLECT:
569         case COLUMN:
570         case COMMENT:
571         case COMMIT:
572         case CONSTRUCTOR:
573         case CONTINUE:
574         case CONVERT:
575         case CURRENT:
576         case CURSOR:
577         case DATA:
578         case DATE:
579         case DAY:
580         case DECLARE:
581         case DELETE:
582         case DISABLE:
583         case EDITIONABLE:
584         case ELEMENT:
585         case ENABLE:
586         case ESCAPE:
587         case EXCEPT:
588         case EXCEPTIONS:
589         case EXECUTE:
590         case EXIT:
591         case EXTERNAL:
592         case EXTENDS:
593         case EXTRACT:
594         case FALSE:
595         case FETCH:
596         case FINAL:
597         case FOR:
598         case FORALL:
599         case FORCE:
600         case FUNCTION:
601         case GLOBAL:
602         case GOTO:
603         case HASH:
604         case HEAP:
605         case HOUR:
606         case IF:
607         case IMMEDIATE:
608         case INDICES:
609         case INDEXTYPE:
610         case INDICATOR:
611         case INSERT:
612         case INSTANTIABLE:
613         case INTERVAL:
614         case INVALIDATE:
615         case ISOLATION:
616         case JAVA:
617         case LEVEL:
618         case LIMIT:
619         case LOCK:
620         case LOOP:
621         case MAP:
622         case MAX:
623         case MEMBER:
624         case MERGE:
625         case MIN:
626         case MINUTE:
627         case MLSLABEL:
628         case MODIFY:
629         case MOD:
630         case MONTH:
631         case NATURAL:
632         case NEW:
633         case NEW_DOT:
634         case NO:
635         case NONEDITIONABLE:
636         case NOT:
637         case NULL:
638         case NULLIF:
639         case OBJECT:
640         case OID:
641         case OPAQUE:
642         case OPEN:
643         case OPERATOR:
644         case ORGANIZATION:
645         case OTHERS:
646         case OVERRIDING:
647         case PACKAGE:
648         case PARTITION:
649         case PIPE:
650         case PRAGMA:
651         case PRESERVE:
652         case PRIVATE:
653         case PROCEDURE:
654         case RAISE:
655         case RANGE:
656         case RAW:
657         case REAL:
658         case RECORD:
659         case REF:
660         case RELEASE:
661         case RELIES_ON:
662         case RENAME:
663         case RESULT:
664         case RETURN:
665         case RETURNING:
666         case REVERSE:
667         case ROLLBACK:
668         case ROW:
669         case ROWS:
670         case ROWID:
671         case ROWNUM:
672         case SAVE:
673         case SAVEPOINT:
674         case SECOND:
675         case SELECT:
676         case SELF:
677         case SET:
678         case SPACE:
679         case SQL:
680         case SQLCODE:
681         case SQLERRM:
682         case STATIC:
683         case SUBTYPE:
684         case SUBSTITUTABLE:
685         case SUCCESSFUL:
686         case SYSDATE:
687         case SYS_REFCURSOR:
688         case TEMPORARY:
689         case TIME:
690         case TIMESTAMP:
691         case TIMEZONE_REGION:
692         case TIMEZONE_ABBR:
693         case TIMEZONE_MINUTE:
694         case TIMEZONE_HOUR:
695         case TRANSACTION:
696         case TRUE:
697         case TYPE:
698         case UNDER:
699         case USING:
700         case WHILE:
701         case YES:
702         case SHOW:
703         case A:
704         case UPDATE:
705         case DOUBLE:
706         case DEC:
707         case PRECISION:
708         case INT:
709         case NUMERIC:
710         case NCHAR:
711         case NVARCHAR2:
712         case STRING:
713         case UROWID:
714         case VARRAY:
715         case VARYING:
716         case BFILE:
717         case BLOB:
718         case CLOB:
719         case NCLOB:
720         case YEAR:
721         case LOCAL:
722         case WITH:
723         case ZONE:
724         case CHARACTER:
725         case AFTER:
726         case BEFORE:
727         case OLD:
728         case PARENT:
729         case CC_IF:
730         case CC_ERROR:
731         case ANALYZE:
732         case ASSOCIATE:
733         case AUDIT:
734         case COMPOUND:
735         case DATABASE:
736         case CALL:
737         case DDL:
738         case DISASSOCIATE:
739         case EACH:
740         case FOLLOWS:
741         case LOGOFF:
742         case LOGON:
743         case NESTED:
744         case NOAUDIT:
745         case SCHEMA:
746         case SERVERERROR:
747         case SHUTDOWN:
748         case STARTUP:
749         case STATEMENT:
750         case STATISTICS:
751         case SUSPEND:
752         case TRUNCATE:
753         case WRAPPED:
754         case LIBRARY:
755         case NAME:
756         case STRUCT:
757         case CONTEXT:
758         case PARAMETERS:
759         case LENGTH:
760         case TDO:
761         case MAXLEN:
762         case CHARSETID:
763         case CHARSETFORM:
764         case ACCEPT:
765         case ACCESSIBLE:
766         case COPY:
767         case DEFINE:
768         case DISCONNECT:
769         case HOST:
770         case PRINT:
771         case QUIT:
772         case REMARK:
773         case UNDEFINE:
774         case VARIABLE:
775         case WHENEVER:
776         case ATTACH:
777         case CAST:
778         case TREAT:
779         case TRIM:
780         case LEFT:
781         case RIGHT:
782         case BOTH:
783         case EMPTY:
784         case MULTISET:
785         case SUBMULTISET:
786         case LEADING:
787         case TRAILING:
788         case CHAR_CS:
789         case NCHAR_CS:
790         case DBTIMEZONE:
791         case SESSIONTIMEZONE:
792         case AUTHENTICATED:
793         case LINK:
794         case SHARED:
795         case DIRECTORY:
796         case USER:
797         case IDENTIFIER:
798         case UNSIGNED_NUMERIC_LITERAL:
799         case CHARACTER_LITERAL:
800         case STRING_LITERAL:
801         case QUOTED_LITERAL:
802           ;
803           break;
804         default:
805           jj_la1[7] = jj_gen;
806           break label_4;
807         }
808         Statement();
809       }
810       switch (jj_nt.kind) {
811       case EXCEPTION:
812         ExceptionHandler();
813         break;
814       default:
815         jj_la1[8] = jj_gen;
816         ;
817       }
818       jj_consume_token(END);
819       switch (jj_nt.kind) {
820       case IDENTIFIER:
821         jj_consume_token(IDENTIFIER);
822         break;
823       default:
824         jj_la1[9] = jj_gen;
825         ;
826       }
827       jjtree.closeNodeScope(jjtn000, true);
828       jjtc000 = false;
829       {if (true) return jjtn000 ;}
830     } catch (Throwable jjte000) {
831       if (jjtc000) {
832         jjtree.clearNodeScope(jjtn000);
833         jjtc000 = false;
834       } else {
835         jjtree.popNode();
836       }
837       if (jjte000 instanceof RuntimeException) {
838         {if (true) throw (RuntimeException)jjte000;}
839       }
840       if (jjte000 instanceof ParseException) {
841         {if (true) throw (ParseException)jjte000;}
842       }
843       {if (true) throw (Error)jjte000;}
844     } finally {
845       if (jjtc000) {
846         jjtree.closeNodeScope(jjtn000, true);
847       }
848     }
849     throw new Error("Missing return statement in function");
850   }
851 
852   final public ASTPackageSpecification PackageSpecification() throws ParseException {
853  /*@bgen(jjtree) PackageSpecification */
854  ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
855  boolean jjtc000 = true;
856  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
857     try {
858       switch (jj_nt.kind) {
859       case CREATE:
860         jj_consume_token(CREATE);
861         switch (jj_nt.kind) {
862         case OR:
863           jj_consume_token(OR);
864           jj_consume_token(REPLACE);
865           break;
866         default:
867           jj_la1[10] = jj_gen;
868           ;
869         }
870         switch (jj_nt.kind) {
871         case EDITIONABLE:
872         case NONEDITIONABLE:
873           switch (jj_nt.kind) {
874           case EDITIONABLE:
875             jj_consume_token(EDITIONABLE);
876             break;
877           case NONEDITIONABLE:
878             jj_consume_token(NONEDITIONABLE);
879             break;
880           default:
881             jj_la1[11] = jj_gen;
882             jj_consume_token(-1);
883             throw new ParseException();
884           }
885           break;
886         default:
887           jj_la1[12] = jj_gen;
888           ;
889         }
890         break;
891       default:
892         jj_la1[13] = jj_gen;
893         ;
894       }
895       jj_consume_token(PACKAGE);
896       simpleNode = ObjectNameDeclaration();
897       label_5:
898       while (true) {
899         switch (jj_nt.kind) {
900         case AUTHID:
901         case ACCESSIBLE:
902           ;
903           break;
904         default:
905           jj_la1[14] = jj_gen;
906           break label_5;
907         }
908         switch (jj_nt.kind) {
909         case AUTHID:
910           jj_consume_token(AUTHID);
911           switch (jj_nt.kind) {
912           case CURRENT_USER:
913             jj_consume_token(CURRENT_USER);
914             break;
915           case DEFINER:
916             jj_consume_token(DEFINER);
917             break;
918           default:
919             jj_la1[15] = jj_gen;
920             jj_consume_token(-1);
921             throw new ParseException();
922           }
923           break;
924         case ACCESSIBLE:
925           AccessibleByClause();
926           break;
927         default:
928           jj_la1[16] = jj_gen;
929           jj_consume_token(-1);
930           throw new ParseException();
931         }
932       }
933       switch (jj_nt.kind) {
934       case WRAPPED:
935         WrappedObject();
936         break;
937       case AS:
938       case IS:
939         switch (jj_nt.kind) {
940         case IS:
941           jj_consume_token(IS);
942           break;
943         case AS:
944           jj_consume_token(AS);
945           break;
946         default:
947           jj_la1[17] = jj_gen;
948           jj_consume_token(-1);
949           throw new ParseException();
950         }
951         DeclarativeSection();
952         jj_consume_token(END);
953         switch (jj_nt.kind) {
954         case REPLACE:
955         case DEFINER:
956         case CURRENT_USER:
957         case SERIALLY_REUSABLE:
958         case RESTRICT_REFERENCES:
959         case EXCEPTION_INIT:
960         case AUTONOMOUS_TRANSACTION:
961         case LANGUAGE:
962         case INLINE:
963         case ADD:
964         case AGGREGATE:
965         case ALL:
966         case ALTER:
967         case AND:
968         case ANY:
969         case ARRAY:
970         case AS:
971         case ASC:
972         case AT:
973         case ATTRIBUTE:
974         case AUTHID:
975         case AVG:
976         case BETWEEN:
977         case BINARY_INTEGER:
978         case BODY:
979         case BOOLEAN:
980         case BULK:
981         case BY:
982         case BYTE:
983         case CASCADE:
984         case CASE:
985         case CHAR:
986         case CHAR_BASE:
987         case CHECK:
988         case CLOSE:
989         case CLUSTER:
990         case COALESCE:
991         case COLLECT:
992         case COLUMN:
993         case COMMENT:
994         case COMMIT:
995         case COMPRESS:
996         case CONNECT:
997         case CONSTANT:
998         case CONSTRUCTOR:
999         case CONTINUE:
1000         case CONVERT:
1001         case CREATE:
1002         case CURRENT:
1003         case CURRVAL:
1004         case CURSOR:
1005         case DATA:
1006         case DATE:
1007         case DAY:
1008         case DECLARE:
1009         case DECIMAL:
1010         case _DEFAULT:
1011         case DELETE:
1012         case DESC:
1013         case DISABLE:
1014         case DISTINCT:
1015         case DO:
1016         case DROP:
1017         case EDITIONABLE:
1018         case ELEMENT:
1019         case ELSE:
1020         case ELSIF:
1021         case ENABLE:
1022         case ESCAPE:
1023         case EXCEPT:
1024         case EXCEPTION:
1025         case EXCEPTIONS:
1026         case EXCLUSIVE:
1027         case EXECUTE:
1028         case EXISTS:
1029         case EXIT:
1030         case EXTERNAL:
1031         case EXTENDS:
1032         case EXTRACT:
1033         case FALSE:
1034         case FETCH:
1035         case FINAL:
1036         case FLOAT:
1037         case FOR:
1038         case FORALL:
1039         case FORCE:
1040         case FROM:
1041         case FUNCTION:
1042         case GLOBAL:
1043         case GOTO:
1044         case GROUP:
1045         case HASH:
1046         case HAVING:
1047         case HEAP:
1048         case HOUR:
1049         case IF:
1050         case IMMEDIATE:
1051         case IN:
1052         case INDEX:
1053         case INDICES:
1054         case INDEXTYPE:
1055         case INDICATOR:
1056         case INSERT:
1057         case INSTANTIABLE:
1058         case INTEGER:
1059         case INTERFACE:
1060         case INTERSECT:
1061         case INTERVAL:
1062         case INTO:
1063         case INVALIDATE:
1064         case IS:
1065         case ISOLATION:
1066         case JAVA:
1067         case LEVEL:
1068         case LIKE:
1069         case LIMIT:
1070         case LIMITED:
1071         case LOCK:
1072         case LONG:
1073         case LOOP:
1074         case MAP:
1075         case MAX:
1076         case MEMBER:
1077         case MERGE:
1078         case MIN:
1079         case MINUS:
1080         case MINUTE:
1081         case MLSLABEL:
1082         case MODIFY:
1083         case MOD:
1084         case MODE:
1085         case MONTH:
1086         case NATURAL:
1087         case NATURALN:
1088         case NEW:
1089         case NEXTVAL:
1090         case NO:
1091         case NOCOPY:
1092         case NONEDITIONABLE:
1093         case NOT:
1094         case NOWAIT:
1095         case NULL:
1096         case NULLIF:
1097         case NUMBER:
1098         case BFILE_BASE:
1099         case BLOB_BASE:
1100         case CLOB_BASE:
1101         case DATE_BASE:
1102         case NUMBER_BASE:
1103         case OBJECT:
1104         case OCIROWID:
1105         case OF:
1106         case OID:
1107         case ON:
1108         case OPAQUE:
1109         case OPEN:
1110         case OPERATOR:
1111         case OPTION:
1112         case OR:
1113         case ORDER:
1114         case ORGANIZATION:
1115         case OTHERS:
1116         case OUT:
1117         case OVERRIDING:
1118         case PACKAGE:
1119         case PARTITION:
1120         case PCTFREE:
1121         case PLS_INTEGER:
1122         case POSITIVE:
1123         case POSITIVEN:
1124         case PRESERVE:
1125         case PRIOR:
1126         case PROMPT:
1127         case PRIVATE:
1128         case PROCEDURE:
1129         case PUBLIC:
1130         case RAISE:
1131         case RANGE:
1132         case RAW:
1133         case REAL:
1134         case RECORD:
1135         case REF:
1136         case RELEASE:
1137         case RELIES_ON:
1138         case RENAME:
1139         case RESULT:
1140         case RETURN:
1141         case RETURNING:
1142         case REVERSE:
1143         case ROLLBACK:
1144         case ROW:
1145         case ROWS:
1146         case ROWID:
1147         case ROWNUM:
1148         case ROWTYPE:
1149         case SAVE:
1150         case SAVEPOINT:
1151         case SECOND:
1152         case SELECT:
1153         case SELF:
1154         case SEPARATE:
1155         case SET:
1156         case SHARE:
1157         case SMALLINT:
1158         case SPACE:
1159         case SQL:
1160         case SQLCODE:
1161         case SQLERRM:
1162         case START:
1163         case STATIC:
1164         case STDDEV:
1165         case SUBTYPE:
1166         case SUBSTITUTABLE:
1167         case SUCCESSFUL:
1168         case SUM:
1169         case SYNONYM:
1170         case SYSDATE:
1171         case SYS_REFCURSOR:
1172         case TABLE:
1173         case TEMPORARY:
1174         case THEN:
1175         case TIME:
1176         case TIMESTAMP:
1177         case TIMEZONE_REGION:
1178         case TIMEZONE_ABBR:
1179         case TIMEZONE_MINUTE:
1180         case TIMEZONE_HOUR:
1181         case TO:
1182         case TRANSACTION:
1183         case TRIGGER:
1184         case TRUE:
1185         case TYPE:
1186         case UI:
1187         case UNDER:
1188         case USING:
1189         case WHILE:
1190         case YES:
1191         case SHOW:
1192         case A:
1193         case UPDATE:
1194         case VARCHAR:
1195         case VARCHAR2:
1196         case DOUBLE:
1197         case DEC:
1198         case PRECISION:
1199         case INT:
1200         case NUMERIC:
1201         case SIGNTYPE:
1202         case NCHAR:
1203         case NVARCHAR2:
1204         case STRING:
1205         case UROWID:
1206         case VARRAY:
1207         case VARYING:
1208         case BFILE:
1209         case BLOB:
1210         case CLOB:
1211         case NCLOB:
1212         case YEAR:
1213         case LOCAL:
1214         case WITH:
1215         case ZONE:
1216         case CHARACTER:
1217         case AFTER:
1218         case BEFORE:
1219         case OLD:
1220         case PARENT:
1221         case ANALYZE:
1222         case ASSOCIATE:
1223         case AUDIT:
1224         case COMPOUND:
1225         case DATABASE:
1226         case CALL:
1227         case DDL:
1228         case DISASSOCIATE:
1229         case EACH:
1230         case FOLLOWS:
1231         case LOGOFF:
1232         case LOGON:
1233         case NESTED:
1234         case NOAUDIT:
1235         case SCHEMA:
1236         case SERVERERROR:
1237         case SHUTDOWN:
1238         case STARTUP:
1239         case STATEMENT:
1240         case STATISTICS:
1241         case SUSPEND:
1242         case TRUNCATE:
1243         case WRAPPED:
1244         case LIBRARY:
1245         case NAME:
1246         case STRUCT:
1247         case CONTEXT:
1248         case PARAMETERS:
1249         case LENGTH:
1250         case TDO:
1251         case MAXLEN:
1252         case CHARSETID:
1253         case CHARSETFORM:
1254         case ACCEPT:
1255         case ACCESSIBLE:
1256         case COPY:
1257         case DEFINE:
1258         case DISCONNECT:
1259         case HOST:
1260         case PRINT:
1261         case QUIT:
1262         case REMARK:
1263         case UNDEFINE:
1264         case VARIABLE:
1265         case WHENEVER:
1266         case ATTACH:
1267         case CAST:
1268         case TREAT:
1269         case TRIM:
1270         case LEFT:
1271         case RIGHT:
1272         case BOTH:
1273         case EMPTY:
1274         case MULTISET:
1275         case SUBMULTISET:
1276         case LEADING:
1277         case TRAILING:
1278         case CHAR_CS:
1279         case NCHAR_CS:
1280         case DBTIMEZONE:
1281         case SESSIONTIMEZONE:
1282         case AUTHENTICATED:
1283         case LINK:
1284         case SHARED:
1285         case DIRECTORY:
1286         case USER:
1287         case IDENTIFIER:
1288         case QUOTED_LITERAL:
1289         case SQLDATA_CLASS:
1290         case CUSTOMDATUM_CLASS:
1291         case ORADATA_CLASS:
1292         case JAVA_INTERFACE_CLASS:
1293           ID();
1294           break;
1295         default:
1296           jj_la1[18] = jj_gen;
1297           ;
1298         }
1299         jj_consume_token(4);
1300         break;
1301       default:
1302         jj_la1[19] = jj_gen;
1303         jj_consume_token(-1);
1304         throw new ParseException();
1305       }
1306         jjtree.closeNodeScope(jjtn000, true);
1307         jjtc000 = false;
1308         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
1309     } catch (Throwable jjte000) {
1310         if (jjtc000) {
1311           jjtree.clearNodeScope(jjtn000);
1312           jjtc000 = false;
1313         } else {
1314           jjtree.popNode();
1315         }
1316         if (jjte000 instanceof RuntimeException) {
1317           {if (true) throw (RuntimeException)jjte000;}
1318         }
1319         if (jjte000 instanceof ParseException) {
1320           {if (true) throw (ParseException)jjte000;}
1321         }
1322         {if (true) throw (Error)jjte000;}
1323     } finally {
1324         if (jjtc000) {
1325           jjtree.closeNodeScope(jjtn000, true);
1326         }
1327     }
1328     throw new Error("Missing return statement in function");
1329   }
1330 
1331   final public ASTPackageBody PackageBody() throws ParseException {
1332  /*@bgen(jjtree) PackageBody */
1333  ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1334  boolean jjtc000 = true;
1335  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1336     try {
1337       switch (jj_nt.kind) {
1338       case CREATE:
1339         jj_consume_token(CREATE);
1340         switch (jj_nt.kind) {
1341         case OR:
1342           jj_consume_token(OR);
1343           jj_consume_token(REPLACE);
1344           break;
1345         default:
1346           jj_la1[20] = jj_gen;
1347           ;
1348         }
1349         switch (jj_nt.kind) {
1350         case EDITIONABLE:
1351         case NONEDITIONABLE:
1352           switch (jj_nt.kind) {
1353           case EDITIONABLE:
1354             jj_consume_token(EDITIONABLE);
1355             break;
1356           case NONEDITIONABLE:
1357             jj_consume_token(NONEDITIONABLE);
1358             break;
1359           default:
1360             jj_la1[21] = jj_gen;
1361             jj_consume_token(-1);
1362             throw new ParseException();
1363           }
1364           break;
1365         default:
1366           jj_la1[22] = jj_gen;
1367           ;
1368         }
1369         break;
1370       default:
1371         jj_la1[23] = jj_gen;
1372         ;
1373       }
1374       switch (jj_nt.kind) {
1375       case PACKAGE:
1376         jj_consume_token(PACKAGE);
1377         break;
1378       case TYPE:
1379         jj_consume_token(TYPE);
1380         break;
1381       default:
1382         jj_la1[24] = jj_gen;
1383         jj_consume_token(-1);
1384         throw new ParseException();
1385       }
1386       jj_consume_token(BODY);
1387       simpleNode = ObjectNameDeclaration();
1388       switch (jj_nt.kind) {
1389       case WRAPPED:
1390         WrappedObject();
1391         break;
1392       case AS:
1393       case IS:
1394         switch (jj_nt.kind) {
1395         case IS:
1396           jj_consume_token(IS);
1397           break;
1398         case AS:
1399           jj_consume_token(AS);
1400           break;
1401         default:
1402           jj_la1[25] = jj_gen;
1403           jj_consume_token(-1);
1404           throw new ParseException();
1405         }
1406         DeclarativeSection();
1407         switch (jj_nt.kind) {
1408         case BEGIN:
1409           jj_consume_token(BEGIN);
1410           label_6:
1411           while (true) {
1412             switch (jj_nt.kind) {
1413             case 5:
1414             case 16:
1415             case 17:
1416             case 21:
1417             case REPLACE:
1418             case DEFINER:
1419             case CURRENT_USER:
1420             case LANGUAGE:
1421             case INLINE:
1422             case ADD:
1423             case AGGREGATE:
1424             case ARRAY:
1425             case AT:
1426             case ATTRIBUTE:
1427             case AUTHID:
1428             case BEGIN:
1429             case BODY:
1430             case BULK:
1431             case BYTE:
1432             case CASCADE:
1433             case CASE:
1434             case CLOSE:
1435             case COALESCE:
1436             case COLLECT:
1437             case COLUMN:
1438             case COMMENT:
1439             case COMMIT:
1440             case CONSTRUCTOR:
1441             case CONTINUE:
1442             case CONVERT:
1443             case CURRENT:
1444             case CURSOR:
1445             case DATA:
1446             case DATE:
1447             case DAY:
1448             case DECLARE:
1449             case DELETE:
1450             case DISABLE:
1451             case EDITIONABLE:
1452             case ELEMENT:
1453             case ENABLE:
1454             case ESCAPE:
1455             case EXCEPT:
1456             case EXCEPTIONS:
1457             case EXECUTE:
1458             case EXIT:
1459             case EXTERNAL:
1460             case EXTENDS:
1461             case EXTRACT:
1462             case FALSE:
1463             case FETCH:
1464             case FINAL:
1465             case FOR:
1466             case FORALL:
1467             case FORCE:
1468             case FUNCTION:
1469             case GLOBAL:
1470             case GOTO:
1471             case HASH:
1472             case HEAP:
1473             case HOUR:
1474             case IF:
1475             case IMMEDIATE:
1476             case INDICES:
1477             case INDEXTYPE:
1478             case INDICATOR:
1479             case INSERT:
1480             case INSTANTIABLE:
1481             case INTERVAL:
1482             case INVALIDATE:
1483             case ISOLATION:
1484             case JAVA:
1485             case LEVEL:
1486             case LIMIT:
1487             case LOCK:
1488             case LOOP:
1489             case MAP:
1490             case MAX:
1491             case MEMBER:
1492             case MERGE:
1493             case MIN:
1494             case MINUTE:
1495             case MLSLABEL:
1496             case MODIFY:
1497             case MOD:
1498             case MONTH:
1499             case NATURAL:
1500             case NEW:
1501             case NEW_DOT:
1502             case NO:
1503             case NONEDITIONABLE:
1504             case NOT:
1505             case NULL:
1506             case NULLIF:
1507             case OBJECT:
1508             case OID:
1509             case OPAQUE:
1510             case OPEN:
1511             case OPERATOR:
1512             case ORGANIZATION:
1513             case OTHERS:
1514             case OVERRIDING:
1515             case PACKAGE:
1516             case PARTITION:
1517             case PIPE:
1518             case PRAGMA:
1519             case PRESERVE:
1520             case PRIVATE:
1521             case PROCEDURE:
1522             case RAISE:
1523             case RANGE:
1524             case RAW:
1525             case REAL:
1526             case RECORD:
1527             case REF:
1528             case RELEASE:
1529             case RELIES_ON:
1530             case RENAME:
1531             case RESULT:
1532             case RETURN:
1533             case RETURNING:
1534             case REVERSE:
1535             case ROLLBACK:
1536             case ROW:
1537             case ROWS:
1538             case ROWID:
1539             case ROWNUM:
1540             case SAVE:
1541             case SAVEPOINT:
1542             case SECOND:
1543             case SELECT:
1544             case SELF:
1545             case SET:
1546             case SPACE:
1547             case SQL:
1548             case SQLCODE:
1549             case SQLERRM:
1550             case STATIC:
1551             case SUBTYPE:
1552             case SUBSTITUTABLE:
1553             case SUCCESSFUL:
1554             case SYSDATE:
1555             case SYS_REFCURSOR:
1556             case TEMPORARY:
1557             case TIME:
1558             case TIMESTAMP:
1559             case TIMEZONE_REGION:
1560             case TIMEZONE_ABBR:
1561             case TIMEZONE_MINUTE:
1562             case TIMEZONE_HOUR:
1563             case TRANSACTION:
1564             case TRUE:
1565             case TYPE:
1566             case UNDER:
1567             case USING:
1568             case WHILE:
1569             case YES:
1570             case SHOW:
1571             case A:
1572             case UPDATE:
1573             case DOUBLE:
1574             case DEC:
1575             case PRECISION:
1576             case INT:
1577             case NUMERIC:
1578             case NCHAR:
1579             case NVARCHAR2:
1580             case STRING:
1581             case UROWID:
1582             case VARRAY:
1583             case VARYING:
1584             case BFILE:
1585             case BLOB:
1586             case CLOB:
1587             case NCLOB:
1588             case YEAR:
1589             case LOCAL:
1590             case WITH:
1591             case ZONE:
1592             case CHARACTER:
1593             case AFTER:
1594             case BEFORE:
1595             case OLD:
1596             case PARENT:
1597             case CC_IF:
1598             case CC_ERROR:
1599             case ANALYZE:
1600             case ASSOCIATE:
1601             case AUDIT:
1602             case COMPOUND:
1603             case DATABASE:
1604             case CALL:
1605             case DDL:
1606             case DISASSOCIATE:
1607             case EACH:
1608             case FOLLOWS:
1609             case LOGOFF:
1610             case LOGON:
1611             case NESTED:
1612             case NOAUDIT:
1613             case SCHEMA:
1614             case SERVERERROR:
1615             case SHUTDOWN:
1616             case STARTUP:
1617             case STATEMENT:
1618             case STATISTICS:
1619             case SUSPEND:
1620             case TRUNCATE:
1621             case WRAPPED:
1622             case LIBRARY:
1623             case NAME:
1624             case STRUCT:
1625             case CONTEXT:
1626             case PARAMETERS:
1627             case LENGTH:
1628             case TDO:
1629             case MAXLEN:
1630             case CHARSETID:
1631             case CHARSETFORM:
1632             case ACCEPT:
1633             case ACCESSIBLE:
1634             case COPY:
1635             case DEFINE:
1636             case DISCONNECT:
1637             case HOST:
1638             case PRINT:
1639             case QUIT:
1640             case REMARK:
1641             case UNDEFINE:
1642             case VARIABLE:
1643             case WHENEVER:
1644             case ATTACH:
1645             case CAST:
1646             case TREAT:
1647             case TRIM:
1648             case LEFT:
1649             case RIGHT:
1650             case BOTH:
1651             case EMPTY:
1652             case MULTISET:
1653             case SUBMULTISET:
1654             case LEADING:
1655             case TRAILING:
1656             case CHAR_CS:
1657             case NCHAR_CS:
1658             case DBTIMEZONE:
1659             case SESSIONTIMEZONE:
1660             case AUTHENTICATED:
1661             case LINK:
1662             case SHARED:
1663             case DIRECTORY:
1664             case USER:
1665             case IDENTIFIER:
1666             case UNSIGNED_NUMERIC_LITERAL:
1667             case CHARACTER_LITERAL:
1668             case STRING_LITERAL:
1669             case QUOTED_LITERAL:
1670               ;
1671               break;
1672             default:
1673               jj_la1[26] = jj_gen;
1674               break label_6;
1675             }
1676             Statement();
1677           }
1678           switch (jj_nt.kind) {
1679           case EXCEPTION:
1680             ExceptionHandler();
1681             break;
1682           default:
1683             jj_la1[27] = jj_gen;
1684             ;
1685           }
1686           break;
1687         default:
1688           jj_la1[28] = jj_gen;
1689           ;
1690         }
1691         jj_consume_token(END);
1692         switch (jj_nt.kind) {
1693         case REPLACE:
1694         case DEFINER:
1695         case CURRENT_USER:
1696         case SERIALLY_REUSABLE:
1697         case RESTRICT_REFERENCES:
1698         case EXCEPTION_INIT:
1699         case AUTONOMOUS_TRANSACTION:
1700         case LANGUAGE:
1701         case INLINE:
1702         case ADD:
1703         case AGGREGATE:
1704         case ALL:
1705         case ALTER:
1706         case AND:
1707         case ANY:
1708         case ARRAY:
1709         case AS:
1710         case ASC:
1711         case AT:
1712         case ATTRIBUTE:
1713         case AUTHID:
1714         case AVG:
1715         case BETWEEN:
1716         case BINARY_INTEGER:
1717         case BODY:
1718         case BOOLEAN:
1719         case BULK:
1720         case BY:
1721         case BYTE:
1722         case CASCADE:
1723         case CASE:
1724         case CHAR:
1725         case CHAR_BASE:
1726         case CHECK:
1727         case CLOSE:
1728         case CLUSTER:
1729         case COALESCE:
1730         case COLLECT:
1731         case COLUMN:
1732         case COMMENT:
1733         case COMMIT:
1734         case COMPRESS:
1735         case CONNECT:
1736         case CONSTANT:
1737         case CONSTRUCTOR:
1738         case CONTINUE:
1739         case CONVERT:
1740         case CREATE:
1741         case CURRENT:
1742         case CURRVAL:
1743         case CURSOR:
1744         case DATA:
1745         case DATE:
1746         case DAY:
1747         case DECLARE:
1748         case DECIMAL:
1749         case _DEFAULT:
1750         case DELETE:
1751         case DESC:
1752         case DISABLE:
1753         case DISTINCT:
1754         case DO:
1755         case DROP:
1756         case EDITIONABLE:
1757         case ELEMENT:
1758         case ELSE:
1759         case ELSIF:
1760         case ENABLE:
1761         case ESCAPE:
1762         case EXCEPT:
1763         case EXCEPTION:
1764         case EXCEPTIONS:
1765         case EXCLUSIVE:
1766         case EXECUTE:
1767         case EXISTS:
1768         case EXIT:
1769         case EXTERNAL:
1770         case EXTENDS:
1771         case EXTRACT:
1772         case FALSE:
1773         case FETCH:
1774         case FINAL:
1775         case FLOAT:
1776         case FOR:
1777         case FORALL:
1778         case FORCE:
1779         case FROM:
1780         case FUNCTION:
1781         case GLOBAL:
1782         case GOTO:
1783         case GROUP:
1784         case HASH:
1785         case HAVING:
1786         case HEAP:
1787         case HOUR:
1788         case IF:
1789         case IMMEDIATE:
1790         case IN:
1791         case INDEX:
1792         case INDICES:
1793         case INDEXTYPE:
1794         case INDICATOR:
1795         case INSERT:
1796         case INSTANTIABLE:
1797         case INTEGER:
1798         case INTERFACE:
1799         case INTERSECT:
1800         case INTERVAL:
1801         case INTO:
1802         case INVALIDATE:
1803         case IS:
1804         case ISOLATION:
1805         case JAVA:
1806         case LEVEL:
1807         case LIKE:
1808         case LIMIT:
1809         case LIMITED:
1810         case LOCK:
1811         case LONG:
1812         case LOOP:
1813         case MAP:
1814         case MAX:
1815         case MEMBER:
1816         case MERGE:
1817         case MIN:
1818         case MINUS:
1819         case MINUTE:
1820         case MLSLABEL:
1821         case MODIFY:
1822         case MOD:
1823         case MODE:
1824         case MONTH:
1825         case NATURAL:
1826         case NATURALN:
1827         case NEW:
1828         case NEXTVAL:
1829         case NO:
1830         case NOCOPY:
1831         case NONEDITIONABLE:
1832         case NOT:
1833         case NOWAIT:
1834         case NULL:
1835         case NULLIF:
1836         case NUMBER:
1837         case BFILE_BASE:
1838         case BLOB_BASE:
1839         case CLOB_BASE:
1840         case DATE_BASE:
1841         case NUMBER_BASE:
1842         case OBJECT:
1843         case OCIROWID:
1844         case OF:
1845         case OID:
1846         case ON:
1847         case OPAQUE:
1848         case OPEN:
1849         case OPERATOR:
1850         case OPTION:
1851         case OR:
1852         case ORDER:
1853         case ORGANIZATION:
1854         case OTHERS:
1855         case OUT:
1856         case OVERRIDING:
1857         case PACKAGE:
1858         case PARTITION:
1859         case PCTFREE:
1860         case PLS_INTEGER:
1861         case POSITIVE:
1862         case POSITIVEN:
1863         case PRESERVE:
1864         case PRIOR:
1865         case PROMPT:
1866         case PRIVATE:
1867         case PROCEDURE:
1868         case PUBLIC:
1869         case RAISE:
1870         case RANGE:
1871         case RAW:
1872         case REAL:
1873         case RECORD:
1874         case REF:
1875         case RELEASE:
1876         case RELIES_ON:
1877         case RENAME:
1878         case RESULT:
1879         case RETURN:
1880         case RETURNING:
1881         case REVERSE:
1882         case ROLLBACK:
1883         case ROW:
1884         case ROWS:
1885         case ROWID:
1886         case ROWNUM:
1887         case ROWTYPE:
1888         case SAVE:
1889         case SAVEPOINT:
1890         case SECOND:
1891         case SELECT:
1892         case SELF:
1893         case SEPARATE:
1894         case SET:
1895         case SHARE:
1896         case SMALLINT:
1897         case SPACE:
1898         case SQL:
1899         case SQLCODE:
1900         case SQLERRM:
1901         case START:
1902         case STATIC:
1903         case STDDEV:
1904         case SUBTYPE:
1905         case SUBSTITUTABLE:
1906         case SUCCESSFUL:
1907         case SUM:
1908         case SYNONYM:
1909         case SYSDATE:
1910         case SYS_REFCURSOR:
1911         case TABLE:
1912         case TEMPORARY:
1913         case THEN:
1914         case TIME:
1915         case TIMESTAMP:
1916         case TIMEZONE_REGION:
1917         case TIMEZONE_ABBR:
1918         case TIMEZONE_MINUTE:
1919         case TIMEZONE_HOUR:
1920         case TO:
1921         case TRANSACTION:
1922         case TRIGGER:
1923         case TRUE:
1924         case TYPE:
1925         case UI:
1926         case UNDER:
1927         case USING:
1928         case WHILE:
1929         case YES:
1930         case SHOW:
1931         case A:
1932         case UPDATE:
1933         case VARCHAR:
1934         case VARCHAR2:
1935         case DOUBLE:
1936         case DEC:
1937         case PRECISION:
1938         case INT:
1939         case NUMERIC:
1940         case SIGNTYPE:
1941         case NCHAR:
1942         case NVARCHAR2:
1943         case STRING:
1944         case UROWID:
1945         case VARRAY:
1946         case VARYING:
1947         case BFILE:
1948         case BLOB:
1949         case CLOB:
1950         case NCLOB:
1951         case YEAR:
1952         case LOCAL:
1953         case WITH:
1954         case ZONE:
1955         case CHARACTER:
1956         case AFTER:
1957         case BEFORE:
1958         case OLD:
1959         case PARENT:
1960         case ANALYZE:
1961         case ASSOCIATE:
1962         case AUDIT:
1963         case COMPOUND:
1964         case DATABASE:
1965         case CALL:
1966         case DDL:
1967         case DISASSOCIATE:
1968         case EACH:
1969         case FOLLOWS:
1970         case LOGOFF:
1971         case LOGON:
1972         case NESTED:
1973         case NOAUDIT:
1974         case SCHEMA:
1975         case SERVERERROR:
1976         case SHUTDOWN:
1977         case STARTUP:
1978         case STATEMENT:
1979         case STATISTICS:
1980         case SUSPEND:
1981         case TRUNCATE:
1982         case WRAPPED:
1983         case LIBRARY:
1984         case NAME:
1985         case STRUCT:
1986         case CONTEXT:
1987         case PARAMETERS:
1988         case LENGTH:
1989         case TDO:
1990         case MAXLEN:
1991         case CHARSETID:
1992         case CHARSETFORM:
1993         case ACCEPT:
1994         case ACCESSIBLE:
1995         case COPY:
1996         case DEFINE:
1997         case DISCONNECT:
1998         case HOST:
1999         case PRINT:
2000         case QUIT:
2001         case REMARK:
2002         case UNDEFINE:
2003         case VARIABLE:
2004         case WHENEVER:
2005         case ATTACH:
2006         case CAST:
2007         case TREAT:
2008         case TRIM:
2009         case LEFT:
2010         case RIGHT:
2011         case BOTH:
2012         case EMPTY:
2013         case MULTISET:
2014         case SUBMULTISET:
2015         case LEADING:
2016         case TRAILING:
2017         case CHAR_CS:
2018         case NCHAR_CS:
2019         case DBTIMEZONE:
2020         case SESSIONTIMEZONE:
2021         case AUTHENTICATED:
2022         case LINK:
2023         case SHARED:
2024         case DIRECTORY:
2025         case USER:
2026         case IDENTIFIER:
2027         case QUOTED_LITERAL:
2028         case SQLDATA_CLASS:
2029         case CUSTOMDATUM_CLASS:
2030         case ORADATA_CLASS:
2031         case JAVA_INTERFACE_CLASS:
2032           ID();
2033           break;
2034         default:
2035           jj_la1[29] = jj_gen;
2036           ;
2037         }
2038         jj_consume_token(4);
2039         break;
2040       default:
2041         jj_la1[30] = jj_gen;
2042         jj_consume_token(-1);
2043         throw new ParseException();
2044       }
2045       jjtree.closeNodeScope(jjtn000, true);
2046       jjtc000 = false;
2047       jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
2048     } catch (Throwable jjte000) {
2049       if (jjtc000) {
2050         jjtree.clearNodeScope(jjtn000);
2051         jjtc000 = false;
2052       } else {
2053         jjtree.popNode();
2054       }
2055       if (jjte000 instanceof RuntimeException) {
2056         {if (true) throw (RuntimeException)jjte000;}
2057       }
2058       if (jjte000 instanceof ParseException) {
2059         {if (true) throw (ParseException)jjte000;}
2060       }
2061       {if (true) throw (Error)jjte000;}
2062     } finally {
2063       if (jjtc000) {
2064         jjtree.closeNodeScope(jjtn000, true);
2065       }
2066     }
2067     throw new Error("Missing return statement in function");
2068   }
2069 
2070   final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2071  /*@bgen(jjtree) DeclarativeUnit */
2072   ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2073   boolean jjtc000 = true;
2074   jjtree.openNodeScope(jjtn000);
2075     try {
2076       switch (jj_nt.kind) {
2077       case PRAGMA:
2078         Pragma();
2079         break;
2080       default:
2081         jj_la1[31] = jj_gen;
2082         if (jj_2_16(2)) {
2083           ExceptionDeclaration();
2084         } else if (jj_2_17(2147483647)) {
2085           SubTypeDefinition();
2086         } else if (jj_2_18(2147483647)) {
2087           ProgramUnit();
2088         } else if (jj_2_19(4)) {
2089           VariableOrConstantDeclaration();
2090         } else if (jj_2_20(2)) {
2091           CursorSpecification();
2092         } else {
2093           switch (jj_nt.kind) {
2094           case CURSOR:
2095             CursorBody();
2096             break;
2097           case IDENTIFIER:
2098             CollectionDeclaration();
2099             break;
2100           case CONSTRUCTOR:
2101           case CREATE:
2102           case FINAL:
2103           case FUNCTION:
2104           case INSTANTIABLE:
2105           case MAP:
2106           case MEMBER:
2107           case NOT:
2108           case ORDER:
2109           case OVERRIDING:
2110           case PROCEDURE:
2111           case STATIC:
2112             MethodDeclaration();
2113             break;
2114           case CC_IF:
2115             CompilationDeclarationFragment();
2116             break;
2117           default:
2118             jj_la1[32] = jj_gen;
2119             jj_consume_token(-1);
2120             throw new ParseException();
2121           }
2122         }
2123       }
2124       jjtree.closeNodeScope(jjtn000, true);
2125       jjtc000 = false;
2126       {if (true) return jjtn000 ;}
2127     } catch (Throwable jjte000) {
2128       if (jjtc000) {
2129         jjtree.clearNodeScope(jjtn000);
2130         jjtc000 = false;
2131       } else {
2132         jjtree.popNode();
2133       }
2134       if (jjte000 instanceof RuntimeException) {
2135         {if (true) throw (RuntimeException)jjte000;}
2136       }
2137       if (jjte000 instanceof ParseException) {
2138         {if (true) throw (ParseException)jjte000;}
2139       }
2140       {if (true) throw (Error)jjte000;}
2141     } finally {
2142       if (jjtc000) {
2143         jjtree.closeNodeScope(jjtn000, true);
2144       }
2145     }
2146     throw new Error("Missing return statement in function");
2147   }
2148 
2149   final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2150  /*@bgen(jjtree) DeclarativeSection */
2151   ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2152   boolean jjtc000 = true;
2153   jjtree.openNodeScope(jjtn000);
2154     try {
2155       label_7:
2156       while (true) {
2157         switch (jj_nt.kind) {
2158         case REPLACE:
2159         case DEFINER:
2160         case CURRENT_USER:
2161         case SERIALLY_REUSABLE:
2162         case RESTRICT_REFERENCES:
2163         case EXCEPTION_INIT:
2164         case AUTONOMOUS_TRANSACTION:
2165         case LANGUAGE:
2166         case INLINE:
2167         case ADD:
2168         case AGGREGATE:
2169         case ALL:
2170         case ALTER:
2171         case AND:
2172         case ANY:
2173         case ARRAY:
2174         case AS:
2175         case ASC:
2176         case AT:
2177         case ATTRIBUTE:
2178         case AUTHID:
2179         case AVG:
2180         case BETWEEN:
2181         case BINARY_INTEGER:
2182         case BODY:
2183         case BOOLEAN:
2184         case BULK:
2185         case BY:
2186         case BYTE:
2187         case CASCADE:
2188         case CASE:
2189         case CHAR:
2190         case CHAR_BASE:
2191         case CHECK:
2192         case CLOSE:
2193         case CLUSTER:
2194         case COALESCE:
2195         case COLLECT:
2196         case COLUMN:
2197         case COMMENT:
2198         case COMMIT:
2199         case COMPRESS:
2200         case CONNECT:
2201         case CONSTANT:
2202         case CONSTRUCTOR:
2203         case CONTINUE:
2204         case CONVERT:
2205         case CREATE:
2206         case CURRENT:
2207         case CURRVAL:
2208         case CURSOR:
2209         case DATA:
2210         case DATE:
2211         case DAY:
2212         case DECLARE:
2213         case DECIMAL:
2214         case _DEFAULT:
2215         case DELETE:
2216         case DESC:
2217         case DISABLE:
2218         case DISTINCT:
2219         case DO:
2220         case DROP:
2221         case EDITIONABLE:
2222         case ELEMENT:
2223         case ELSE:
2224         case ELSIF:
2225         case ENABLE:
2226         case ESCAPE:
2227         case EXCEPT:
2228         case EXCEPTION:
2229         case EXCEPTIONS:
2230         case EXCLUSIVE:
2231         case EXECUTE:
2232         case EXISTS:
2233         case EXIT:
2234         case EXTERNAL:
2235         case EXTENDS:
2236         case EXTRACT:
2237         case FALSE:
2238         case FETCH:
2239         case FINAL:
2240         case FLOAT:
2241         case FOR:
2242         case FORALL:
2243         case FORCE:
2244         case FROM:
2245         case FUNCTION:
2246         case GLOBAL:
2247         case GOTO:
2248         case GROUP:
2249         case HASH:
2250         case HAVING:
2251         case HEAP:
2252         case HOUR:
2253         case IF:
2254         case IMMEDIATE:
2255         case IN:
2256         case INDEX:
2257         case INDICES:
2258         case INDEXTYPE:
2259         case INDICATOR:
2260         case INSERT:
2261         case INSTANTIABLE:
2262         case INTEGER:
2263         case INTERFACE:
2264         case INTERSECT:
2265         case INTERVAL:
2266         case INTO:
2267         case INVALIDATE:
2268         case IS:
2269         case ISOLATION:
2270         case JAVA:
2271         case LEVEL:
2272         case LIKE:
2273         case LIMIT:
2274         case LIMITED:
2275         case LOCK:
2276         case LONG:
2277         case LOOP:
2278         case MAP:
2279         case MAX:
2280         case MEMBER:
2281         case MERGE:
2282         case MIN:
2283         case MINUS:
2284         case MINUTE:
2285         case MLSLABEL:
2286         case MODIFY:
2287         case MOD:
2288         case MODE:
2289         case MONTH:
2290         case NATURAL:
2291         case NATURALN:
2292         case NEW:
2293         case NEXTVAL:
2294         case NO:
2295         case NOCOPY:
2296         case NONEDITIONABLE:
2297         case NOT:
2298         case NOWAIT:
2299         case NULL:
2300         case NULLIF:
2301         case NUMBER:
2302         case BFILE_BASE:
2303         case BLOB_BASE:
2304         case CLOB_BASE:
2305         case DATE_BASE:
2306         case NUMBER_BASE:
2307         case OBJECT:
2308         case OCIROWID:
2309         case OF:
2310         case OID:
2311         case ON:
2312         case OPAQUE:
2313         case OPEN:
2314         case OPERATOR:
2315         case OPTION:
2316         case OR:
2317         case ORDER:
2318         case ORGANIZATION:
2319         case OTHERS:
2320         case OUT:
2321         case OVERRIDING:
2322         case PACKAGE:
2323         case PARTITION:
2324         case PCTFREE:
2325         case PLS_INTEGER:
2326         case POSITIVE:
2327         case POSITIVEN:
2328         case PRAGMA:
2329         case PRESERVE:
2330         case PRIOR:
2331         case PROMPT:
2332         case PRIVATE:
2333         case PROCEDURE:
2334         case PUBLIC:
2335         case RAISE:
2336         case RANGE:
2337         case RAW:
2338         case REAL:
2339         case RECORD:
2340         case REF:
2341         case RELEASE:
2342         case RELIES_ON:
2343         case RENAME:
2344         case RESULT:
2345         case RETURN:
2346         case RETURNING:
2347         case REVERSE:
2348         case ROLLBACK:
2349         case ROW:
2350         case ROWS:
2351         case ROWID:
2352         case ROWNUM:
2353         case ROWTYPE:
2354         case SAVE:
2355         case SAVEPOINT:
2356         case SECOND:
2357         case SELECT:
2358         case SELF:
2359         case SEPARATE:
2360         case SET:
2361         case SHARE:
2362         case SMALLINT:
2363         case SPACE:
2364         case SQL:
2365         case SQLCODE:
2366         case SQLERRM:
2367         case START:
2368         case STATIC:
2369         case STDDEV:
2370         case SUBTYPE:
2371         case SUBSTITUTABLE:
2372         case SUCCESSFUL:
2373         case SUM:
2374         case SYNONYM:
2375         case SYSDATE:
2376         case SYS_REFCURSOR:
2377         case TABLE:
2378         case TEMPORARY:
2379         case THEN:
2380         case TIME:
2381         case TIMESTAMP:
2382         case TIMEZONE_REGION:
2383         case TIMEZONE_ABBR:
2384         case TIMEZONE_MINUTE:
2385         case TIMEZONE_HOUR:
2386         case TO:
2387         case TRANSACTION:
2388         case TRIGGER:
2389         case TRUE:
2390         case TYPE:
2391         case UI:
2392         case UNDER:
2393         case USING:
2394         case WHILE:
2395         case YES:
2396         case SHOW:
2397         case A:
2398         case UPDATE:
2399         case VARCHAR:
2400         case VARCHAR2:
2401         case DOUBLE:
2402         case DEC:
2403         case PRECISION:
2404         case INT:
2405         case NUMERIC:
2406         case SIGNTYPE:
2407         case NCHAR:
2408         case NVARCHAR2:
2409         case STRING:
2410         case UROWID:
2411         case VARRAY:
2412         case VARYING:
2413         case BFILE:
2414         case BLOB:
2415         case CLOB:
2416         case NCLOB:
2417         case YEAR:
2418         case LOCAL:
2419         case WITH:
2420         case ZONE:
2421         case CHARACTER:
2422         case AFTER:
2423         case BEFORE:
2424         case OLD:
2425         case PARENT:
2426         case CC_IF:
2427         case ANALYZE:
2428         case ASSOCIATE:
2429         case AUDIT:
2430         case COMPOUND:
2431         case DATABASE:
2432         case CALL:
2433         case DDL:
2434         case DISASSOCIATE:
2435         case EACH:
2436         case FOLLOWS:
2437         case LOGOFF:
2438         case LOGON:
2439         case NESTED:
2440         case NOAUDIT:
2441         case SCHEMA:
2442         case SERVERERROR:
2443         case SHUTDOWN:
2444         case STARTUP:
2445         case STATEMENT:
2446         case STATISTICS:
2447         case SUSPEND:
2448         case TRUNCATE:
2449         case WRAPPED:
2450         case LIBRARY:
2451         case NAME:
2452         case STRUCT:
2453         case CONTEXT:
2454         case PARAMETERS:
2455         case LENGTH:
2456         case TDO:
2457         case MAXLEN:
2458         case CHARSETID:
2459         case CHARSETFORM:
2460         case ACCEPT:
2461         case ACCESSIBLE:
2462         case COPY:
2463         case DEFINE:
2464         case DISCONNECT:
2465         case HOST:
2466         case PRINT:
2467         case QUIT:
2468         case REMARK:
2469         case UNDEFINE:
2470         case VARIABLE:
2471         case WHENEVER:
2472         case ATTACH:
2473         case CAST:
2474         case TREAT:
2475         case TRIM:
2476         case LEFT:
2477         case RIGHT:
2478         case BOTH:
2479         case EMPTY:
2480         case MULTISET:
2481         case SUBMULTISET:
2482         case LEADING:
2483         case TRAILING:
2484         case CHAR_CS:
2485         case NCHAR_CS:
2486         case DBTIMEZONE:
2487         case SESSIONTIMEZONE:
2488         case AUTHENTICATED:
2489         case LINK:
2490         case SHARED:
2491         case DIRECTORY:
2492         case USER:
2493         case IDENTIFIER:
2494         case QUOTED_LITERAL:
2495         case SQLDATA_CLASS:
2496         case CUSTOMDATUM_CLASS:
2497         case ORADATA_CLASS:
2498         case JAVA_INTERFACE_CLASS:
2499           ;
2500           break;
2501         default:
2502           jj_la1[33] = jj_gen;
2503           break label_7;
2504         }
2505         DeclarativeUnit();
2506       }
2507         jjtree.closeNodeScope(jjtn000, true);
2508         jjtc000 = false;
2509         {if (true) return jjtn000 ;}
2510     } catch (Throwable jjte000) {
2511           if (jjtc000) {
2512             jjtree.clearNodeScope(jjtn000);
2513             jjtc000 = false;
2514           } else {
2515             jjtree.popNode();
2516           }
2517           if (jjte000 instanceof RuntimeException) {
2518             {if (true) throw (RuntimeException)jjte000;}
2519           }
2520           if (jjte000 instanceof ParseException) {
2521             {if (true) throw (ParseException)jjte000;}
2522           }
2523           {if (true) throw (Error)jjte000;}
2524     } finally {
2525           if (jjtc000) {
2526             jjtree.closeNodeScope(jjtn000, true);
2527           }
2528     }
2529     throw new Error("Missing return statement in function");
2530   }
2531 
2532   final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2533  /*@bgen(jjtree) CompilationDeclarationFragment */
2534   ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2535   boolean jjtc000 = true;
2536   jjtree.openNodeScope(jjtn000);
2537     try {
2538       jj_consume_token(CC_IF);
2539       ConditionalOrExpression();
2540       jj_consume_token(CC_THEN);
2541       label_8:
2542       while (true) {
2543         switch (jj_nt.kind) {
2544         case REPLACE:
2545         case DEFINER:
2546         case CURRENT_USER:
2547         case SERIALLY_REUSABLE:
2548         case RESTRICT_REFERENCES:
2549         case EXCEPTION_INIT:
2550         case AUTONOMOUS_TRANSACTION:
2551         case LANGUAGE:
2552         case INLINE:
2553         case ADD:
2554         case AGGREGATE:
2555         case ALL:
2556         case ALTER:
2557         case AND:
2558         case ANY:
2559         case ARRAY:
2560         case AS:
2561         case ASC:
2562         case AT:
2563         case ATTRIBUTE:
2564         case AUTHID:
2565         case AVG:
2566         case BETWEEN:
2567         case BINARY_INTEGER:
2568         case BODY:
2569         case BOOLEAN:
2570         case BULK:
2571         case BY:
2572         case BYTE:
2573         case CASCADE:
2574         case CASE:
2575         case CHAR:
2576         case CHAR_BASE:
2577         case CHECK:
2578         case CLOSE:
2579         case CLUSTER:
2580         case COALESCE:
2581         case COLLECT:
2582         case COLUMN:
2583         case COMMENT:
2584         case COMMIT:
2585         case COMPRESS:
2586         case CONNECT:
2587         case CONSTANT:
2588         case CONSTRUCTOR:
2589         case CONTINUE:
2590         case CONVERT:
2591         case CREATE:
2592         case CURRENT:
2593         case CURRVAL:
2594         case CURSOR:
2595         case DATA:
2596         case DATE:
2597         case DAY:
2598         case DECLARE:
2599         case DECIMAL:
2600         case _DEFAULT:
2601         case DELETE:
2602         case DESC:
2603         case DISABLE:
2604         case DISTINCT:
2605         case DO:
2606         case DROP:
2607         case EDITIONABLE:
2608         case ELEMENT:
2609         case ELSE:
2610         case ELSIF:
2611         case ENABLE:
2612         case ESCAPE:
2613         case EXCEPT:
2614         case EXCEPTION:
2615         case EXCEPTIONS:
2616         case EXCLUSIVE:
2617         case EXECUTE:
2618         case EXISTS:
2619         case EXIT:
2620         case EXTERNAL:
2621         case EXTENDS:
2622         case EXTRACT:
2623         case FALSE:
2624         case FETCH:
2625         case FINAL:
2626         case FLOAT:
2627         case FOR:
2628         case FORALL:
2629         case FORCE:
2630         case FROM:
2631         case FUNCTION:
2632         case GLOBAL:
2633         case GOTO:
2634         case GROUP:
2635         case HASH:
2636         case HAVING:
2637         case HEAP:
2638         case HOUR:
2639         case IF:
2640         case IMMEDIATE:
2641         case IN:
2642         case INDEX:
2643         case INDICES:
2644         case INDEXTYPE:
2645         case INDICATOR:
2646         case INSERT:
2647         case INSTANTIABLE:
2648         case INTEGER:
2649         case INTERFACE:
2650         case INTERSECT:
2651         case INTERVAL:
2652         case INTO:
2653         case INVALIDATE:
2654         case IS:
2655         case ISOLATION:
2656         case JAVA:
2657         case LEVEL:
2658         case LIKE:
2659         case LIMIT:
2660         case LIMITED:
2661         case LOCK:
2662         case LONG:
2663         case LOOP:
2664         case MAP:
2665         case MAX:
2666         case MEMBER:
2667         case MERGE:
2668         case MIN:
2669         case MINUS:
2670         case MINUTE:
2671         case MLSLABEL:
2672         case MODIFY:
2673         case MOD:
2674         case MODE:
2675         case MONTH:
2676         case NATURAL:
2677         case NATURALN:
2678         case NEW:
2679         case NEXTVAL:
2680         case NO:
2681         case NOCOPY:
2682         case NONEDITIONABLE:
2683         case NOT:
2684         case NOWAIT:
2685         case NULL:
2686         case NULLIF:
2687         case NUMBER:
2688         case BFILE_BASE:
2689         case BLOB_BASE:
2690         case CLOB_BASE:
2691         case DATE_BASE:
2692         case NUMBER_BASE:
2693         case OBJECT:
2694         case OCIROWID:
2695         case OF:
2696         case OID:
2697         case ON:
2698         case OPAQUE:
2699         case OPEN:
2700         case OPERATOR:
2701         case OPTION:
2702         case OR:
2703         case ORDER:
2704         case ORGANIZATION:
2705         case OTHERS:
2706         case OUT:
2707         case OVERRIDING:
2708         case PACKAGE:
2709         case PARTITION:
2710         case PCTFREE:
2711         case PLS_INTEGER:
2712         case POSITIVE:
2713         case POSITIVEN:
2714         case PRAGMA:
2715         case PRESERVE:
2716         case PRIOR:
2717         case PROMPT:
2718         case PRIVATE:
2719         case PROCEDURE:
2720         case PUBLIC:
2721         case RAISE:
2722         case RANGE:
2723         case RAW:
2724         case REAL:
2725         case RECORD:
2726         case REF:
2727         case RELEASE:
2728         case RELIES_ON:
2729         case RENAME:
2730         case RESULT:
2731         case RETURN:
2732         case RETURNING:
2733         case REVERSE:
2734         case ROLLBACK:
2735         case ROW:
2736         case ROWS:
2737         case ROWID:
2738         case ROWNUM:
2739         case ROWTYPE:
2740         case SAVE:
2741         case SAVEPOINT:
2742         case SECOND:
2743         case SELECT:
2744         case SELF:
2745         case SEPARATE:
2746         case SET:
2747         case SHARE:
2748         case SMALLINT:
2749         case SPACE:
2750         case SQL:
2751         case SQLCODE:
2752         case SQLERRM:
2753         case START:
2754         case STATIC:
2755         case STDDEV:
2756         case SUBTYPE:
2757         case SUBSTITUTABLE:
2758         case SUCCESSFUL:
2759         case SUM:
2760         case SYNONYM:
2761         case SYSDATE:
2762         case SYS_REFCURSOR:
2763         case TABLE:
2764         case TEMPORARY:
2765         case THEN:
2766         case TIME:
2767         case TIMESTAMP:
2768         case TIMEZONE_REGION:
2769         case TIMEZONE_ABBR:
2770         case TIMEZONE_MINUTE:
2771         case TIMEZONE_HOUR:
2772         case TO:
2773         case TRANSACTION:
2774         case TRIGGER:
2775         case TRUE:
2776         case TYPE:
2777         case UI:
2778         case UNDER:
2779         case USING:
2780         case WHILE:
2781         case YES:
2782         case SHOW:
2783         case A:
2784         case UPDATE:
2785         case VARCHAR:
2786         case VARCHAR2:
2787         case DOUBLE:
2788         case DEC:
2789         case PRECISION:
2790         case INT:
2791         case NUMERIC:
2792         case SIGNTYPE:
2793         case NCHAR:
2794         case NVARCHAR2:
2795         case STRING:
2796         case UROWID:
2797         case VARRAY:
2798         case VARYING:
2799         case BFILE:
2800         case BLOB:
2801         case CLOB:
2802         case NCLOB:
2803         case YEAR:
2804         case LOCAL:
2805         case WITH:
2806         case ZONE:
2807         case CHARACTER:
2808         case AFTER:
2809         case BEFORE:
2810         case OLD:
2811         case PARENT:
2812         case CC_IF:
2813         case CC_ERROR:
2814         case ANALYZE:
2815         case ASSOCIATE:
2816         case AUDIT:
2817         case COMPOUND:
2818         case DATABASE:
2819         case CALL:
2820         case DDL:
2821         case DISASSOCIATE:
2822         case EACH:
2823         case FOLLOWS:
2824         case LOGOFF:
2825         case LOGON:
2826         case NESTED:
2827         case NOAUDIT:
2828         case SCHEMA:
2829         case SERVERERROR:
2830         case SHUTDOWN:
2831         case STARTUP:
2832         case STATEMENT:
2833         case STATISTICS:
2834         case SUSPEND:
2835         case TRUNCATE:
2836         case WRAPPED:
2837         case LIBRARY:
2838         case NAME:
2839         case STRUCT:
2840         case CONTEXT:
2841         case PARAMETERS:
2842         case LENGTH:
2843         case TDO:
2844         case MAXLEN:
2845         case CHARSETID:
2846         case CHARSETFORM:
2847         case ACCEPT:
2848         case ACCESSIBLE:
2849         case COPY:
2850         case DEFINE:
2851         case DISCONNECT:
2852         case HOST:
2853         case PRINT:
2854         case QUIT:
2855         case REMARK:
2856         case UNDEFINE:
2857         case VARIABLE:
2858         case WHENEVER:
2859         case ATTACH:
2860         case CAST:
2861         case TREAT:
2862         case TRIM:
2863         case LEFT:
2864         case RIGHT:
2865         case BOTH:
2866         case EMPTY:
2867         case MULTISET:
2868         case SUBMULTISET:
2869         case LEADING:
2870         case TRAILING:
2871         case CHAR_CS:
2872         case NCHAR_CS:
2873         case DBTIMEZONE:
2874         case SESSIONTIMEZONE:
2875         case AUTHENTICATED:
2876         case LINK:
2877         case SHARED:
2878         case DIRECTORY:
2879         case USER:
2880         case IDENTIFIER:
2881         case QUOTED_LITERAL:
2882         case SQLDATA_CLASS:
2883         case CUSTOMDATUM_CLASS:
2884         case ORADATA_CLASS:
2885         case JAVA_INTERFACE_CLASS:
2886           ;
2887           break;
2888         default:
2889           jj_la1[34] = jj_gen;
2890           break label_8;
2891         }
2892         switch (jj_nt.kind) {
2893         case REPLACE:
2894         case DEFINER:
2895         case CURRENT_USER:
2896         case SERIALLY_REUSABLE:
2897         case RESTRICT_REFERENCES:
2898         case EXCEPTION_INIT:
2899         case AUTONOMOUS_TRANSACTION:
2900         case LANGUAGE:
2901         case INLINE:
2902         case ADD:
2903         case AGGREGATE:
2904         case ALL:
2905         case ALTER:
2906         case AND:
2907         case ANY:
2908         case ARRAY:
2909         case AS:
2910         case ASC:
2911         case AT:
2912         case ATTRIBUTE:
2913         case AUTHID:
2914         case AVG:
2915         case BETWEEN:
2916         case BINARY_INTEGER:
2917         case BODY:
2918         case BOOLEAN:
2919         case BULK:
2920         case BY:
2921         case BYTE:
2922         case CASCADE:
2923         case CASE:
2924         case CHAR:
2925         case CHAR_BASE:
2926         case CHECK:
2927         case CLOSE:
2928         case CLUSTER:
2929         case COALESCE:
2930         case COLLECT:
2931         case COLUMN:
2932         case COMMENT:
2933         case COMMIT:
2934         case COMPRESS:
2935         case CONNECT:
2936         case CONSTANT:
2937         case CONSTRUCTOR:
2938         case CONTINUE:
2939         case CONVERT:
2940         case CREATE:
2941         case CURRENT:
2942         case CURRVAL:
2943         case CURSOR:
2944         case DATA:
2945         case DATE:
2946         case DAY:
2947         case DECLARE:
2948         case DECIMAL:
2949         case _DEFAULT:
2950         case DELETE:
2951         case DESC:
2952         case DISABLE:
2953         case DISTINCT:
2954         case DO:
2955         case DROP:
2956         case EDITIONABLE:
2957         case ELEMENT:
2958         case ELSE:
2959         case ELSIF:
2960         case ENABLE:
2961         case ESCAPE:
2962         case EXCEPT:
2963         case EXCEPTION:
2964         case EXCEPTIONS:
2965         case EXCLUSIVE:
2966         case EXECUTE:
2967         case EXISTS:
2968         case EXIT:
2969         case EXTERNAL:
2970         case EXTENDS:
2971         case EXTRACT:
2972         case FALSE:
2973         case FETCH:
2974         case FINAL:
2975         case FLOAT:
2976         case FOR:
2977         case FORALL:
2978         case FORCE:
2979         case FROM:
2980         case FUNCTION:
2981         case GLOBAL:
2982         case GOTO:
2983         case GROUP:
2984         case HASH:
2985         case HAVING:
2986         case HEAP:
2987         case HOUR:
2988         case IF:
2989         case IMMEDIATE:
2990         case IN:
2991         case INDEX:
2992         case INDICES:
2993         case INDEXTYPE:
2994         case INDICATOR:
2995         case INSERT:
2996         case INSTANTIABLE:
2997         case INTEGER:
2998         case INTERFACE:
2999         case INTERSECT:
3000         case INTERVAL:
3001         case INTO:
3002         case INVALIDATE:
3003         case IS:
3004         case ISOLATION:
3005         case JAVA:
3006         case LEVEL:
3007         case LIKE:
3008         case LIMIT:
3009         case LIMITED:
3010         case LOCK:
3011         case LONG:
3012         case LOOP:
3013         case MAP:
3014         case MAX:
3015         case MEMBER:
3016         case MERGE:
3017         case MIN:
3018         case MINUS:
3019         case MINUTE:
3020         case MLSLABEL:
3021         case MODIFY:
3022         case MOD:
3023         case MODE:
3024         case MONTH:
3025         case NATURAL:
3026         case NATURALN:
3027         case NEW:
3028         case NEXTVAL:
3029         case NO:
3030         case NOCOPY:
3031         case NONEDITIONABLE:
3032         case NOT:
3033         case NOWAIT:
3034         case NULL:
3035         case NULLIF:
3036         case NUMBER:
3037         case BFILE_BASE:
3038         case BLOB_BASE:
3039         case CLOB_BASE:
3040         case DATE_BASE:
3041         case NUMBER_BASE:
3042         case OBJECT:
3043         case OCIROWID:
3044         case OF:
3045         case OID:
3046         case ON:
3047         case OPAQUE:
3048         case OPEN:
3049         case OPERATOR:
3050         case OPTION:
3051         case OR:
3052         case ORDER:
3053         case ORGANIZATION:
3054         case OTHERS:
3055         case OUT:
3056         case OVERRIDING:
3057         case PACKAGE:
3058         case PARTITION:
3059         case PCTFREE:
3060         case PLS_INTEGER:
3061         case POSITIVE:
3062         case POSITIVEN:
3063         case PRAGMA:
3064         case PRESERVE:
3065         case PRIOR:
3066         case PROMPT:
3067         case PRIVATE:
3068         case PROCEDURE:
3069         case PUBLIC:
3070         case RAISE:
3071         case RANGE:
3072         case RAW:
3073         case REAL:
3074         case RECORD:
3075         case REF:
3076         case RELEASE:
3077         case RELIES_ON:
3078         case RENAME:
3079         case RESULT:
3080         case RETURN:
3081         case RETURNING:
3082         case REVERSE:
3083         case ROLLBACK:
3084         case ROW:
3085         case ROWS:
3086         case ROWID:
3087         case ROWNUM:
3088         case ROWTYPE:
3089         case SAVE:
3090         case SAVEPOINT:
3091         case SECOND:
3092         case SELECT:
3093         case SELF:
3094         case SEPARATE:
3095         case SET:
3096         case SHARE:
3097         case SMALLINT:
3098         case SPACE:
3099         case SQL:
3100         case SQLCODE:
3101         case SQLERRM:
3102         case START:
3103         case STATIC:
3104         case STDDEV:
3105         case SUBTYPE:
3106         case SUBSTITUTABLE:
3107         case SUCCESSFUL:
3108         case SUM:
3109         case SYNONYM:
3110         case SYSDATE:
3111         case SYS_REFCURSOR:
3112         case TABLE:
3113         case TEMPORARY:
3114         case THEN:
3115         case TIME:
3116         case TIMESTAMP:
3117         case TIMEZONE_REGION:
3118         case TIMEZONE_ABBR:
3119         case TIMEZONE_MINUTE:
3120         case TIMEZONE_HOUR:
3121         case TO:
3122         case TRANSACTION:
3123         case TRIGGER:
3124         case TRUE:
3125         case TYPE:
3126         case UI:
3127         case UNDER:
3128         case USING:
3129         case WHILE:
3130         case YES:
3131         case SHOW:
3132         case A:
3133         case UPDATE:
3134         case VARCHAR:
3135         case VARCHAR2:
3136         case DOUBLE:
3137         case DEC:
3138         case PRECISION:
3139         case INT:
3140         case NUMERIC:
3141         case SIGNTYPE:
3142         case NCHAR:
3143         case NVARCHAR2:
3144         case STRING:
3145         case UROWID:
3146         case VARRAY:
3147         case VARYING:
3148         case BFILE:
3149         case BLOB:
3150         case CLOB:
3151         case NCLOB:
3152         case YEAR:
3153         case LOCAL:
3154         case WITH:
3155         case ZONE:
3156         case CHARACTER:
3157         case AFTER:
3158         case BEFORE:
3159         case OLD:
3160         case PARENT:
3161         case CC_IF:
3162         case ANALYZE:
3163         case ASSOCIATE:
3164         case AUDIT:
3165         case COMPOUND:
3166         case DATABASE:
3167         case CALL:
3168         case DDL:
3169         case DISASSOCIATE:
3170         case EACH:
3171         case FOLLOWS:
3172         case LOGOFF:
3173         case LOGON:
3174         case NESTED:
3175         case NOAUDIT:
3176         case SCHEMA:
3177         case SERVERERROR:
3178         case SHUTDOWN:
3179         case STARTUP:
3180         case STATEMENT:
3181         case STATISTICS:
3182         case SUSPEND:
3183         case TRUNCATE:
3184         case WRAPPED:
3185         case LIBRARY:
3186         case NAME:
3187         case STRUCT:
3188         case CONTEXT:
3189         case PARAMETERS:
3190         case LENGTH:
3191         case TDO:
3192         case MAXLEN:
3193         case CHARSETID:
3194         case CHARSETFORM:
3195         case ACCEPT:
3196         case ACCESSIBLE:
3197         case COPY:
3198         case DEFINE:
3199         case DISCONNECT:
3200         case HOST:
3201         case PRINT:
3202         case QUIT:
3203         case REMARK:
3204         case UNDEFINE:
3205         case VARIABLE:
3206         case WHENEVER:
3207         case ATTACH:
3208         case CAST:
3209         case TREAT:
3210         case TRIM:
3211         case LEFT:
3212         case RIGHT:
3213         case BOTH:
3214         case EMPTY:
3215         case MULTISET:
3216         case SUBMULTISET:
3217         case LEADING:
3218         case TRAILING:
3219         case CHAR_CS:
3220         case NCHAR_CS:
3221         case DBTIMEZONE:
3222         case SESSIONTIMEZONE:
3223         case AUTHENTICATED:
3224         case LINK:
3225         case SHARED:
3226         case DIRECTORY:
3227         case USER:
3228         case IDENTIFIER:
3229         case QUOTED_LITERAL:
3230         case SQLDATA_CLASS:
3231         case CUSTOMDATUM_CLASS:
3232         case ORADATA_CLASS:
3233         case JAVA_INTERFACE_CLASS:
3234           DeclarativeUnit();
3235           break;
3236         case CC_ERROR:
3237           jj_consume_token(CC_ERROR);
3238           Expression();
3239           jj_consume_token(CC_END);
3240           break;
3241         default:
3242           jj_la1[35] = jj_gen;
3243           jj_consume_token(-1);
3244           throw new ParseException();
3245         }
3246       }
3247       label_9:
3248       while (true) {
3249         switch (jj_nt.kind) {
3250         case CC_ELSIF:
3251           ;
3252           break;
3253         default:
3254           jj_la1[36] = jj_gen;
3255           break label_9;
3256         }
3257         jj_consume_token(CC_ELSIF);
3258         ConditionalOrExpression();
3259         jj_consume_token(CC_THEN);
3260         label_10:
3261         while (true) {
3262           switch (jj_nt.kind) {
3263           case REPLACE:
3264           case DEFINER:
3265           case CURRENT_USER:
3266           case SERIALLY_REUSABLE:
3267           case RESTRICT_REFERENCES:
3268           case EXCEPTION_INIT:
3269           case AUTONOMOUS_TRANSACTION:
3270           case LANGUAGE:
3271           case INLINE:
3272           case ADD:
3273           case AGGREGATE:
3274           case ALL:
3275           case ALTER:
3276           case AND:
3277           case ANY:
3278           case ARRAY:
3279           case AS:
3280           case ASC:
3281           case AT:
3282           case ATTRIBUTE:
3283           case AUTHID:
3284           case AVG:
3285           case BETWEEN:
3286           case BINARY_INTEGER:
3287           case BODY:
3288           case BOOLEAN:
3289           case BULK:
3290           case BY:
3291           case BYTE:
3292           case CASCADE:
3293           case CASE:
3294           case CHAR:
3295           case CHAR_BASE:
3296           case CHECK:
3297           case CLOSE:
3298           case CLUSTER:
3299           case COALESCE:
3300           case COLLECT:
3301           case COLUMN:
3302           case COMMENT:
3303           case COMMIT:
3304           case COMPRESS:
3305           case CONNECT:
3306           case CONSTANT:
3307           case CONSTRUCTOR:
3308           case CONTINUE:
3309           case CONVERT:
3310           case CREATE:
3311           case CURRENT:
3312           case CURRVAL:
3313           case CURSOR:
3314           case DATA:
3315           case DATE:
3316           case DAY:
3317           case DECLARE:
3318           case DECIMAL:
3319           case _DEFAULT:
3320           case DELETE:
3321           case DESC:
3322           case DISABLE:
3323           case DISTINCT:
3324           case DO:
3325           case DROP:
3326           case EDITIONABLE:
3327           case ELEMENT:
3328           case ELSE:
3329           case ELSIF:
3330           case ENABLE:
3331           case ESCAPE:
3332           case EXCEPT:
3333           case EXCEPTION:
3334           case EXCEPTIONS:
3335           case EXCLUSIVE:
3336           case EXECUTE:
3337           case EXISTS:
3338           case EXIT:
3339           case EXTERNAL:
3340           case EXTENDS:
3341           case EXTRACT:
3342           case FALSE:
3343           case FETCH:
3344           case FINAL:
3345           case FLOAT:
3346           case FOR:
3347           case FORALL:
3348           case FORCE:
3349           case FROM:
3350           case FUNCTION:
3351           case GLOBAL:
3352           case GOTO:
3353           case GROUP:
3354           case HASH:
3355           case HAVING:
3356           case HEAP:
3357           case HOUR:
3358           case IF:
3359           case IMMEDIATE:
3360           case IN:
3361           case INDEX:
3362           case INDICES:
3363           case INDEXTYPE:
3364           case INDICATOR:
3365           case INSERT:
3366           case INSTANTIABLE:
3367           case INTEGER:
3368           case INTERFACE:
3369           case INTERSECT:
3370           case INTERVAL:
3371           case INTO:
3372           case INVALIDATE:
3373           case IS:
3374           case ISOLATION:
3375           case JAVA:
3376           case LEVEL:
3377           case LIKE:
3378           case LIMIT:
3379           case LIMITED:
3380           case LOCK:
3381           case LONG:
3382           case LOOP:
3383           case MAP:
3384           case MAX:
3385           case MEMBER:
3386           case MERGE:
3387           case MIN:
3388           case MINUS:
3389           case MINUTE:
3390           case MLSLABEL:
3391           case MODIFY:
3392           case MOD:
3393           case MODE:
3394           case MONTH:
3395           case NATURAL:
3396           case NATURALN:
3397           case NEW:
3398           case NEXTVAL:
3399           case NO:
3400           case NOCOPY:
3401           case NONEDITIONABLE:
3402           case NOT:
3403           case NOWAIT:
3404           case NULL:
3405           case NULLIF:
3406           case NUMBER:
3407           case BFILE_BASE:
3408           case BLOB_BASE:
3409           case CLOB_BASE:
3410           case DATE_BASE:
3411           case NUMBER_BASE:
3412           case OBJECT:
3413           case OCIROWID:
3414           case OF:
3415           case OID:
3416           case ON:
3417           case OPAQUE:
3418           case OPEN:
3419           case OPERATOR:
3420           case OPTION:
3421           case OR:
3422           case ORDER:
3423           case ORGANIZATION:
3424           case OTHERS:
3425           case OUT:
3426           case OVERRIDING:
3427           case PACKAGE:
3428           case PARTITION:
3429           case PCTFREE:
3430           case PLS_INTEGER:
3431           case POSITIVE:
3432           case POSITIVEN:
3433           case PRAGMA:
3434           case PRESERVE:
3435           case PRIOR:
3436           case PROMPT:
3437           case PRIVATE:
3438           case PROCEDURE:
3439           case PUBLIC:
3440           case RAISE:
3441           case RANGE:
3442           case RAW:
3443           case REAL:
3444           case RECORD:
3445           case REF:
3446           case RELEASE:
3447           case RELIES_ON:
3448           case RENAME:
3449           case RESULT:
3450           case RETURN:
3451           case RETURNING:
3452           case REVERSE:
3453           case ROLLBACK:
3454           case ROW:
3455           case ROWS:
3456           case ROWID:
3457           case ROWNUM:
3458           case ROWTYPE:
3459           case SAVE:
3460           case SAVEPOINT:
3461           case SECOND:
3462           case SELECT:
3463           case SELF:
3464           case SEPARATE:
3465           case SET:
3466           case SHARE:
3467           case SMALLINT:
3468           case SPACE:
3469           case SQL:
3470           case SQLCODE:
3471           case SQLERRM:
3472           case START:
3473           case STATIC:
3474           case STDDEV:
3475           case SUBTYPE:
3476           case SUBSTITUTABLE:
3477           case SUCCESSFUL:
3478           case SUM:
3479           case SYNONYM:
3480           case SYSDATE:
3481           case SYS_REFCURSOR:
3482           case TABLE:
3483           case TEMPORARY:
3484           case THEN:
3485           case TIME:
3486           case TIMESTAMP:
3487           case TIMEZONE_REGION:
3488           case TIMEZONE_ABBR:
3489           case TIMEZONE_MINUTE:
3490           case TIMEZONE_HOUR:
3491           case TO:
3492           case TRANSACTION:
3493           case TRIGGER:
3494           case TRUE:
3495           case TYPE:
3496           case UI:
3497           case UNDER:
3498           case USING:
3499           case WHILE:
3500           case YES:
3501           case SHOW:
3502           case A:
3503           case UPDATE:
3504           case VARCHAR:
3505           case VARCHAR2:
3506           case DOUBLE:
3507           case DEC:
3508           case PRECISION:
3509           case INT:
3510           case NUMERIC:
3511           case SIGNTYPE:
3512           case NCHAR:
3513           case NVARCHAR2:
3514           case STRING:
3515           case UROWID:
3516           case VARRAY:
3517           case VARYING:
3518           case BFILE:
3519           case BLOB:
3520           case CLOB:
3521           case NCLOB:
3522           case YEAR:
3523           case LOCAL:
3524           case WITH:
3525           case ZONE:
3526           case CHARACTER:
3527           case AFTER:
3528           case BEFORE:
3529           case OLD:
3530           case PARENT:
3531           case CC_IF:
3532           case CC_ERROR:
3533           case ANALYZE:
3534           case ASSOCIATE:
3535           case AUDIT:
3536           case COMPOUND:
3537           case DATABASE:
3538           case CALL:
3539           case DDL:
3540           case DISASSOCIATE:
3541           case EACH:
3542           case FOLLOWS:
3543           case LOGOFF:
3544           case LOGON:
3545           case NESTED:
3546           case NOAUDIT:
3547           case SCHEMA:
3548           case SERVERERROR:
3549           case SHUTDOWN:
3550           case STARTUP:
3551           case STATEMENT:
3552           case STATISTICS:
3553           case SUSPEND:
3554           case TRUNCATE:
3555           case WRAPPED:
3556           case LIBRARY:
3557           case NAME:
3558           case STRUCT:
3559           case CONTEXT:
3560           case PARAMETERS:
3561           case LENGTH:
3562           case TDO:
3563           case MAXLEN:
3564           case CHARSETID:
3565           case CHARSETFORM:
3566           case ACCEPT:
3567           case ACCESSIBLE:
3568           case COPY:
3569           case DEFINE:
3570           case DISCONNECT:
3571           case HOST:
3572           case PRINT:
3573           case QUIT:
3574           case REMARK:
3575           case UNDEFINE:
3576           case VARIABLE:
3577           case WHENEVER:
3578           case ATTACH:
3579           case CAST:
3580           case TREAT:
3581           case TRIM:
3582           case LEFT:
3583           case RIGHT:
3584           case BOTH:
3585           case EMPTY:
3586           case MULTISET:
3587           case SUBMULTISET:
3588           case LEADING:
3589           case TRAILING:
3590           case CHAR_CS:
3591           case NCHAR_CS:
3592           case DBTIMEZONE:
3593           case SESSIONTIMEZONE:
3594           case AUTHENTICATED:
3595           case LINK:
3596           case SHARED:
3597           case DIRECTORY:
3598           case USER:
3599           case IDENTIFIER:
3600           case QUOTED_LITERAL:
3601           case SQLDATA_CLASS:
3602           case CUSTOMDATUM_CLASS:
3603           case ORADATA_CLASS:
3604           case JAVA_INTERFACE_CLASS:
3605             ;
3606             break;
3607           default:
3608             jj_la1[37] = jj_gen;
3609             break label_10;
3610           }
3611           switch (jj_nt.kind) {
3612           case REPLACE:
3613           case DEFINER:
3614           case CURRENT_USER:
3615           case SERIALLY_REUSABLE:
3616           case RESTRICT_REFERENCES:
3617           case EXCEPTION_INIT:
3618           case AUTONOMOUS_TRANSACTION:
3619           case LANGUAGE:
3620           case INLINE:
3621           case ADD:
3622           case AGGREGATE:
3623           case ALL:
3624           case ALTER:
3625           case AND:
3626           case ANY:
3627           case ARRAY:
3628           case AS:
3629           case ASC:
3630           case AT:
3631           case ATTRIBUTE:
3632           case AUTHID:
3633           case AVG:
3634           case BETWEEN:
3635           case BINARY_INTEGER:
3636           case BODY:
3637           case BOOLEAN:
3638           case BULK:
3639           case BY:
3640           case BYTE:
3641           case CASCADE:
3642           case CASE:
3643           case CHAR:
3644           case CHAR_BASE:
3645           case CHECK:
3646           case CLOSE:
3647           case CLUSTER:
3648           case COALESCE:
3649           case COLLECT:
3650           case COLUMN:
3651           case COMMENT:
3652           case COMMIT:
3653           case COMPRESS:
3654           case CONNECT:
3655           case CONSTANT:
3656           case CONSTRUCTOR:
3657           case CONTINUE:
3658           case CONVERT:
3659           case CREATE:
3660           case CURRENT:
3661           case CURRVAL:
3662           case CURSOR:
3663           case DATA:
3664           case DATE:
3665           case DAY:
3666           case DECLARE:
3667           case DECIMAL:
3668           case _DEFAULT:
3669           case DELETE:
3670           case DESC:
3671           case DISABLE:
3672           case DISTINCT:
3673           case DO:
3674           case DROP:
3675           case EDITIONABLE:
3676           case ELEMENT:
3677           case ELSE:
3678           case ELSIF:
3679           case ENABLE:
3680           case ESCAPE:
3681           case EXCEPT:
3682           case EXCEPTION:
3683           case EXCEPTIONS:
3684           case EXCLUSIVE:
3685           case EXECUTE:
3686           case EXISTS:
3687           case EXIT:
3688           case EXTERNAL:
3689           case EXTENDS:
3690           case EXTRACT:
3691           case FALSE:
3692           case FETCH:
3693           case FINAL:
3694           case FLOAT:
3695           case FOR:
3696           case FORALL:
3697           case FORCE:
3698           case FROM:
3699           case FUNCTION:
3700           case GLOBAL:
3701           case GOTO:
3702           case GROUP:
3703           case HASH:
3704           case HAVING:
3705           case HEAP:
3706           case HOUR:
3707           case IF:
3708           case IMMEDIATE:
3709           case IN:
3710           case INDEX:
3711           case INDICES:
3712           case INDEXTYPE:
3713           case INDICATOR:
3714           case INSERT:
3715           case INSTANTIABLE:
3716           case INTEGER:
3717           case INTERFACE:
3718           case INTERSECT:
3719           case INTERVAL:
3720           case INTO:
3721           case INVALIDATE:
3722           case IS:
3723           case ISOLATION:
3724           case JAVA:
3725           case LEVEL:
3726           case LIKE:
3727           case LIMIT:
3728           case LIMITED:
3729           case LOCK:
3730           case LONG:
3731           case LOOP:
3732           case MAP:
3733           case MAX:
3734           case MEMBER:
3735           case MERGE:
3736           case MIN:
3737           case MINUS:
3738           case MINUTE:
3739           case MLSLABEL:
3740           case MODIFY:
3741           case MOD:
3742           case MODE:
3743           case MONTH:
3744           case NATURAL:
3745           case NATURALN:
3746           case NEW:
3747           case NEXTVAL:
3748           case NO:
3749           case NOCOPY:
3750           case NONEDITIONABLE:
3751           case NOT:
3752           case NOWAIT:
3753           case NULL:
3754           case NULLIF:
3755           case NUMBER:
3756           case BFILE_BASE:
3757           case BLOB_BASE:
3758           case CLOB_BASE:
3759           case DATE_BASE:
3760           case NUMBER_BASE:
3761           case OBJECT:
3762           case OCIROWID:
3763           case OF:
3764           case OID:
3765           case ON:
3766           case OPAQUE:
3767           case OPEN:
3768           case OPERATOR:
3769           case OPTION:
3770           case OR:
3771           case ORDER:
3772           case ORGANIZATION:
3773           case OTHERS:
3774           case OUT:
3775           case OVERRIDING:
3776           case PACKAGE:
3777           case PARTITION:
3778           case PCTFREE:
3779           case PLS_INTEGER:
3780           case POSITIVE:
3781           case POSITIVEN:
3782           case PRAGMA:
3783           case PRESERVE:
3784           case PRIOR:
3785           case PROMPT:
3786           case PRIVATE:
3787           case PROCEDURE:
3788           case PUBLIC:
3789           case RAISE:
3790           case RANGE:
3791           case RAW:
3792           case REAL:
3793           case RECORD:
3794           case REF:
3795           case RELEASE:
3796           case RELIES_ON:
3797           case RENAME:
3798           case RESULT:
3799           case RETURN:
3800           case RETURNING:
3801           case REVERSE:
3802           case ROLLBACK:
3803           case ROW:
3804           case ROWS:
3805           case ROWID:
3806           case ROWNUM:
3807           case ROWTYPE:
3808           case SAVE:
3809           case SAVEPOINT:
3810           case SECOND:
3811           case SELECT:
3812           case SELF:
3813           case SEPARATE:
3814           case SET:
3815           case SHARE:
3816           case SMALLINT:
3817           case SPACE:
3818           case SQL:
3819           case SQLCODE:
3820           case SQLERRM:
3821           case START:
3822           case STATIC:
3823           case STDDEV:
3824           case SUBTYPE:
3825           case SUBSTITUTABLE:
3826           case SUCCESSFUL:
3827           case SUM:
3828           case SYNONYM:
3829           case SYSDATE:
3830           case SYS_REFCURSOR:
3831           case TABLE:
3832           case TEMPORARY:
3833           case THEN:
3834           case TIME:
3835           case TIMESTAMP:
3836           case TIMEZONE_REGION:
3837           case TIMEZONE_ABBR:
3838           case TIMEZONE_MINUTE:
3839           case TIMEZONE_HOUR:
3840           case TO:
3841           case TRANSACTION:
3842           case TRIGGER:
3843           case TRUE:
3844           case TYPE:
3845           case UI:
3846           case UNDER:
3847           case USING:
3848           case WHILE:
3849           case YES:
3850           case SHOW:
3851           case A:
3852           case UPDATE:
3853           case VARCHAR:
3854           case VARCHAR2:
3855           case DOUBLE:
3856           case DEC:
3857           case PRECISION:
3858           case INT:
3859           case NUMERIC:
3860           case SIGNTYPE:
3861           case NCHAR:
3862           case NVARCHAR2:
3863           case STRING:
3864           case UROWID:
3865           case VARRAY:
3866           case VARYING:
3867           case BFILE:
3868           case BLOB:
3869           case CLOB:
3870           case NCLOB:
3871           case YEAR:
3872           case LOCAL:
3873           case WITH:
3874           case ZONE:
3875           case CHARACTER:
3876           case AFTER:
3877           case BEFORE:
3878           case OLD:
3879           case PARENT:
3880           case CC_IF:
3881           case ANALYZE:
3882           case ASSOCIATE:
3883           case AUDIT:
3884           case COMPOUND:
3885           case DATABASE:
3886           case CALL:
3887           case DDL:
3888           case DISASSOCIATE:
3889           case EACH:
3890           case FOLLOWS:
3891           case LOGOFF:
3892           case LOGON:
3893           case NESTED:
3894           case NOAUDIT:
3895           case SCHEMA:
3896           case SERVERERROR:
3897           case SHUTDOWN:
3898           case STARTUP:
3899           case STATEMENT:
3900           case STATISTICS:
3901           case SUSPEND:
3902           case TRUNCATE:
3903           case WRAPPED:
3904           case LIBRARY:
3905           case NAME:
3906           case STRUCT:
3907           case CONTEXT:
3908           case PARAMETERS:
3909           case LENGTH:
3910           case TDO:
3911           case MAXLEN:
3912           case CHARSETID:
3913           case CHARSETFORM:
3914           case ACCEPT:
3915           case ACCESSIBLE:
3916           case COPY:
3917           case DEFINE:
3918           case DISCONNECT:
3919           case HOST:
3920           case PRINT:
3921           case QUIT:
3922           case REMARK:
3923           case UNDEFINE:
3924           case VARIABLE:
3925           case WHENEVER:
3926           case ATTACH:
3927           case CAST:
3928           case TREAT:
3929           case TRIM:
3930           case LEFT:
3931           case RIGHT:
3932           case BOTH:
3933           case EMPTY:
3934           case MULTISET:
3935           case SUBMULTISET:
3936           case LEADING:
3937           case TRAILING:
3938           case CHAR_CS:
3939           case NCHAR_CS:
3940           case DBTIMEZONE:
3941           case SESSIONTIMEZONE:
3942           case AUTHENTICATED:
3943           case LINK:
3944           case SHARED:
3945           case DIRECTORY:
3946           case USER:
3947           case IDENTIFIER:
3948           case QUOTED_LITERAL:
3949           case SQLDATA_CLASS:
3950           case CUSTOMDATUM_CLASS:
3951           case ORADATA_CLASS:
3952           case JAVA_INTERFACE_CLASS:
3953             DeclarativeUnit();
3954             break;
3955           case CC_ERROR:
3956             jj_consume_token(CC_ERROR);
3957             Expression();
3958             jj_consume_token(CC_END);
3959             break;
3960           default:
3961             jj_la1[38] = jj_gen;
3962             jj_consume_token(-1);
3963             throw new ParseException();
3964           }
3965         }
3966       }
3967       label_11:
3968       while (true) {
3969         switch (jj_nt.kind) {
3970         case CC_ELSE:
3971           ;
3972           break;
3973         default:
3974           jj_la1[39] = jj_gen;
3975           break label_11;
3976         }
3977         jj_consume_token(CC_ELSE);
3978         label_12:
3979         while (true) {
3980           switch (jj_nt.kind) {
3981           case REPLACE:
3982           case DEFINER:
3983           case CURRENT_USER:
3984           case SERIALLY_REUSABLE:
3985           case RESTRICT_REFERENCES:
3986           case EXCEPTION_INIT:
3987           case AUTONOMOUS_TRANSACTION:
3988           case LANGUAGE:
3989           case INLINE:
3990           case ADD:
3991           case AGGREGATE:
3992           case ALL:
3993           case ALTER:
3994           case AND:
3995           case ANY:
3996           case ARRAY:
3997           case AS:
3998           case ASC:
3999           case AT:
4000           case ATTRIBUTE:
4001           case AUTHID:
4002           case AVG:
4003           case BETWEEN:
4004           case BINARY_INTEGER:
4005           case BODY:
4006           case BOOLEAN:
4007           case BULK:
4008           case BY:
4009           case BYTE:
4010           case CASCADE:
4011           case CASE:
4012           case CHAR:
4013           case CHAR_BASE:
4014           case CHECK:
4015           case CLOSE:
4016           case CLUSTER:
4017           case COALESCE:
4018           case COLLECT:
4019           case COLUMN:
4020           case COMMENT:
4021           case COMMIT:
4022           case COMPRESS:
4023           case CONNECT:
4024           case CONSTANT:
4025           case CONSTRUCTOR:
4026           case CONTINUE:
4027           case CONVERT:
4028           case CREATE:
4029           case CURRENT:
4030           case CURRVAL:
4031           case CURSOR:
4032           case DATA:
4033           case DATE:
4034           case DAY:
4035           case DECLARE:
4036           case DECIMAL:
4037           case _DEFAULT:
4038           case DELETE:
4039           case DESC:
4040           case DISABLE:
4041           case DISTINCT:
4042           case DO:
4043           case DROP:
4044           case EDITIONABLE:
4045           case ELEMENT:
4046           case ELSE:
4047           case ELSIF:
4048           case ENABLE:
4049           case ESCAPE:
4050           case EXCEPT:
4051           case EXCEPTION:
4052           case EXCEPTIONS:
4053           case EXCLUSIVE:
4054           case EXECUTE:
4055           case EXISTS:
4056           case EXIT:
4057           case EXTERNAL:
4058           case EXTENDS:
4059           case EXTRACT:
4060           case FALSE:
4061           case FETCH:
4062           case FINAL:
4063           case FLOAT:
4064           case FOR:
4065           case FORALL:
4066           case FORCE:
4067           case FROM:
4068           case FUNCTION:
4069           case GLOBAL:
4070           case GOTO:
4071           case GROUP:
4072           case HASH:
4073           case HAVING:
4074           case HEAP:
4075           case HOUR:
4076           case IF:
4077           case IMMEDIATE:
4078           case IN:
4079           case INDEX:
4080           case INDICES:
4081           case INDEXTYPE:
4082           case INDICATOR:
4083           case INSERT:
4084           case INSTANTIABLE:
4085           case INTEGER:
4086           case INTERFACE:
4087           case INTERSECT:
4088           case INTERVAL:
4089           case INTO:
4090           case INVALIDATE:
4091           case IS:
4092           case ISOLATION:
4093           case JAVA:
4094           case LEVEL:
4095           case LIKE:
4096           case LIMIT:
4097           case LIMITED:
4098           case LOCK:
4099           case LONG:
4100           case LOOP:
4101           case MAP:
4102           case MAX:
4103           case MEMBER:
4104           case MERGE:
4105           case MIN:
4106           case MINUS:
4107           case MINUTE:
4108           case MLSLABEL:
4109           case MODIFY:
4110           case MOD:
4111           case MODE:
4112           case MONTH:
4113           case NATURAL:
4114           case NATURALN:
4115           case NEW:
4116           case NEXTVAL:
4117           case NO:
4118           case NOCOPY:
4119           case NONEDITIONABLE:
4120           case NOT:
4121           case NOWAIT:
4122           case NULL:
4123           case NULLIF:
4124           case NUMBER:
4125           case BFILE_BASE:
4126           case BLOB_BASE:
4127           case CLOB_BASE:
4128           case DATE_BASE:
4129           case NUMBER_BASE:
4130           case OBJECT:
4131           case OCIROWID:
4132           case OF:
4133           case OID:
4134           case ON:
4135           case OPAQUE:
4136           case OPEN:
4137           case OPERATOR:
4138           case OPTION:
4139           case OR:
4140           case ORDER:
4141           case ORGANIZATION:
4142           case OTHERS:
4143           case OUT:
4144           case OVERRIDING:
4145           case PACKAGE:
4146           case PARTITION:
4147           case PCTFREE:
4148           case PLS_INTEGER:
4149           case POSITIVE:
4150           case POSITIVEN:
4151           case PRAGMA:
4152           case PRESERVE:
4153           case PRIOR:
4154           case PROMPT:
4155           case PRIVATE:
4156           case PROCEDURE:
4157           case PUBLIC:
4158           case RAISE:
4159           case RANGE:
4160           case RAW:
4161           case REAL:
4162           case RECORD:
4163           case REF:
4164           case RELEASE:
4165           case RELIES_ON:
4166           case RENAME:
4167           case RESULT:
4168           case RETURN:
4169           case RETURNING:
4170           case REVERSE:
4171           case ROLLBACK:
4172           case ROW:
4173           case ROWS:
4174           case ROWID:
4175           case ROWNUM:
4176           case ROWTYPE:
4177           case SAVE:
4178           case SAVEPOINT:
4179           case SECOND:
4180           case SELECT:
4181           case SELF:
4182           case SEPARATE:
4183           case SET:
4184           case SHARE:
4185           case SMALLINT:
4186           case SPACE:
4187           case SQL:
4188           case SQLCODE:
4189           case SQLERRM:
4190           case START:
4191           case STATIC:
4192           case STDDEV:
4193           case SUBTYPE:
4194           case SUBSTITUTABLE:
4195           case SUCCESSFUL:
4196           case SUM:
4197           case SYNONYM:
4198           case SYSDATE:
4199           case SYS_REFCURSOR:
4200           case TABLE:
4201           case TEMPORARY:
4202           case THEN:
4203           case TIME:
4204           case TIMESTAMP:
4205           case TIMEZONE_REGION:
4206           case TIMEZONE_ABBR:
4207           case TIMEZONE_MINUTE:
4208           case TIMEZONE_HOUR:
4209           case TO:
4210           case TRANSACTION:
4211           case TRIGGER:
4212           case TRUE:
4213           case TYPE:
4214           case UI:
4215           case UNDER:
4216           case USING:
4217           case WHILE:
4218           case YES:
4219           case SHOW:
4220           case A:
4221           case UPDATE:
4222           case VARCHAR:
4223           case VARCHAR2:
4224           case DOUBLE:
4225           case DEC:
4226           case PRECISION:
4227           case INT:
4228           case NUMERIC:
4229           case SIGNTYPE:
4230           case NCHAR:
4231           case NVARCHAR2:
4232           case STRING:
4233           case UROWID:
4234           case VARRAY:
4235           case VARYING:
4236           case BFILE:
4237           case BLOB:
4238           case CLOB:
4239           case NCLOB:
4240           case YEAR:
4241           case LOCAL:
4242           case WITH:
4243           case ZONE:
4244           case CHARACTER:
4245           case AFTER:
4246           case BEFORE:
4247           case OLD:
4248           case PARENT:
4249           case CC_IF:
4250           case CC_ERROR:
4251           case ANALYZE:
4252           case ASSOCIATE:
4253           case AUDIT:
4254           case COMPOUND:
4255           case DATABASE:
4256           case CALL:
4257           case DDL:
4258           case DISASSOCIATE:
4259           case EACH:
4260           case FOLLOWS:
4261           case LOGOFF:
4262           case LOGON:
4263           case NESTED:
4264           case NOAUDIT:
4265           case SCHEMA:
4266           case SERVERERROR:
4267           case SHUTDOWN:
4268           case STARTUP:
4269           case STATEMENT:
4270           case STATISTICS:
4271           case SUSPEND:
4272           case TRUNCATE:
4273           case WRAPPED:
4274           case LIBRARY:
4275           case NAME:
4276           case STRUCT:
4277           case CONTEXT:
4278           case PARAMETERS:
4279           case LENGTH:
4280           case TDO:
4281           case MAXLEN:
4282           case CHARSETID:
4283           case CHARSETFORM:
4284           case ACCEPT:
4285           case ACCESSIBLE:
4286           case COPY:
4287           case DEFINE:
4288           case DISCONNECT:
4289           case HOST:
4290           case PRINT:
4291           case QUIT:
4292           case REMARK:
4293           case UNDEFINE:
4294           case VARIABLE:
4295           case WHENEVER:
4296           case ATTACH:
4297           case CAST:
4298           case TREAT:
4299           case TRIM:
4300           case LEFT:
4301           case RIGHT:
4302           case BOTH:
4303           case EMPTY:
4304           case MULTISET:
4305           case SUBMULTISET:
4306           case LEADING:
4307           case TRAILING:
4308           case CHAR_CS:
4309           case NCHAR_CS:
4310           case DBTIMEZONE:
4311           case SESSIONTIMEZONE:
4312           case AUTHENTICATED:
4313           case LINK:
4314           case SHARED:
4315           case DIRECTORY:
4316           case USER:
4317           case IDENTIFIER:
4318           case QUOTED_LITERAL:
4319           case SQLDATA_CLASS:
4320           case CUSTOMDATUM_CLASS:
4321           case ORADATA_CLASS:
4322           case JAVA_INTERFACE_CLASS:
4323             ;
4324             break;
4325           default:
4326             jj_la1[40] = jj_gen;
4327             break label_12;
4328           }
4329           switch (jj_nt.kind) {
4330           case REPLACE:
4331           case DEFINER:
4332           case CURRENT_USER:
4333           case SERIALLY_REUSABLE:
4334           case RESTRICT_REFERENCES:
4335           case EXCEPTION_INIT:
4336           case AUTONOMOUS_TRANSACTION:
4337           case LANGUAGE:
4338           case INLINE:
4339           case ADD:
4340           case AGGREGATE:
4341           case ALL:
4342           case ALTER:
4343           case AND:
4344           case ANY:
4345           case ARRAY:
4346           case AS:
4347           case ASC:
4348           case AT:
4349           case ATTRIBUTE:
4350           case AUTHID:
4351           case AVG:
4352           case BETWEEN:
4353           case BINARY_INTEGER:
4354           case BODY:
4355           case BOOLEAN:
4356           case BULK:
4357           case BY:
4358           case BYTE:
4359           case CASCADE:
4360           case CASE:
4361           case CHAR:
4362           case CHAR_BASE:
4363           case CHECK:
4364           case CLOSE:
4365           case CLUSTER:
4366           case COALESCE:
4367           case COLLECT:
4368           case COLUMN:
4369           case COMMENT:
4370           case COMMIT:
4371           case COMPRESS:
4372           case CONNECT:
4373           case CONSTANT:
4374           case CONSTRUCTOR:
4375           case CONTINUE:
4376           case CONVERT:
4377           case CREATE:
4378           case CURRENT:
4379           case CURRVAL:
4380           case CURSOR:
4381           case DATA:
4382           case DATE:
4383           case DAY:
4384           case DECLARE:
4385           case DECIMAL:
4386           case _DEFAULT:
4387           case DELETE:
4388           case DESC:
4389           case DISABLE:
4390           case DISTINCT:
4391           case DO:
4392           case DROP:
4393           case EDITIONABLE:
4394           case ELEMENT:
4395           case ELSE:
4396           case ELSIF:
4397           case ENABLE:
4398           case ESCAPE:
4399           case EXCEPT:
4400           case EXCEPTION:
4401           case EXCEPTIONS:
4402           case EXCLUSIVE:
4403           case EXECUTE:
4404           case EXISTS:
4405           case EXIT:
4406           case EXTERNAL:
4407           case EXTENDS:
4408           case EXTRACT:
4409           case FALSE:
4410           case FETCH:
4411           case FINAL:
4412           case FLOAT:
4413           case FOR:
4414           case FORALL:
4415           case FORCE:
4416           case FROM:
4417           case FUNCTION:
4418           case GLOBAL:
4419           case GOTO:
4420           case GROUP:
4421           case HASH:
4422           case HAVING:
4423           case HEAP:
4424           case HOUR:
4425           case IF:
4426           case IMMEDIATE:
4427           case IN:
4428           case INDEX:
4429           case INDICES:
4430           case INDEXTYPE:
4431           case INDICATOR:
4432           case INSERT:
4433           case INSTANTIABLE:
4434           case INTEGER:
4435           case INTERFACE:
4436           case INTERSECT:
4437           case INTERVAL:
4438           case INTO:
4439           case INVALIDATE:
4440           case IS:
4441           case ISOLATION:
4442           case JAVA:
4443           case LEVEL:
4444           case LIKE:
4445           case LIMIT:
4446           case LIMITED:
4447           case LOCK:
4448           case LONG:
4449           case LOOP:
4450           case MAP:
4451           case MAX:
4452           case MEMBER:
4453           case MERGE:
4454           case MIN:
4455           case MINUS:
4456           case MINUTE:
4457           case MLSLABEL:
4458           case MODIFY:
4459           case MOD:
4460           case MODE:
4461           case MONTH:
4462           case NATURAL:
4463           case NATURALN:
4464           case NEW:
4465           case NEXTVAL:
4466           case NO:
4467           case NOCOPY:
4468           case NONEDITIONABLE:
4469           case NOT:
4470           case NOWAIT:
4471           case NULL:
4472           case NULLIF:
4473           case NUMBER:
4474           case BFILE_BASE:
4475           case BLOB_BASE:
4476           case CLOB_BASE:
4477           case DATE_BASE:
4478           case NUMBER_BASE:
4479           case OBJECT:
4480           case OCIROWID:
4481           case OF:
4482           case OID:
4483           case ON:
4484           case OPAQUE:
4485           case OPEN:
4486           case OPERATOR:
4487           case OPTION:
4488           case OR:
4489           case ORDER:
4490           case ORGANIZATION:
4491           case OTHERS:
4492           case OUT:
4493           case OVERRIDING:
4494           case PACKAGE:
4495           case PARTITION:
4496           case PCTFREE:
4497           case PLS_INTEGER:
4498           case POSITIVE:
4499           case POSITIVEN:
4500           case PRAGMA:
4501           case PRESERVE:
4502           case PRIOR:
4503           case PROMPT:
4504           case PRIVATE:
4505           case PROCEDURE:
4506           case PUBLIC:
4507           case RAISE:
4508           case RANGE:
4509           case RAW:
4510           case REAL:
4511           case RECORD:
4512           case REF:
4513           case RELEASE:
4514           case RELIES_ON:
4515           case RENAME:
4516           case RESULT:
4517           case RETURN:
4518           case RETURNING:
4519           case REVERSE:
4520           case ROLLBACK:
4521           case ROW:
4522           case ROWS:
4523           case ROWID:
4524           case ROWNUM:
4525           case ROWTYPE:
4526           case SAVE:
4527           case SAVEPOINT:
4528           case SECOND:
4529           case SELECT:
4530           case SELF:
4531           case SEPARATE:
4532           case SET:
4533           case SHARE:
4534           case SMALLINT:
4535           case SPACE:
4536           case SQL:
4537           case SQLCODE:
4538           case SQLERRM:
4539           case START:
4540           case STATIC:
4541           case STDDEV:
4542           case SUBTYPE:
4543           case SUBSTITUTABLE:
4544           case SUCCESSFUL:
4545           case SUM:
4546           case SYNONYM:
4547           case SYSDATE:
4548           case SYS_REFCURSOR:
4549           case TABLE:
4550           case TEMPORARY:
4551           case THEN:
4552           case TIME:
4553           case TIMESTAMP:
4554           case TIMEZONE_REGION:
4555           case TIMEZONE_ABBR:
4556           case TIMEZONE_MINUTE:
4557           case TIMEZONE_HOUR:
4558           case TO:
4559           case TRANSACTION:
4560           case TRIGGER:
4561           case TRUE:
4562           case TYPE:
4563           case UI:
4564           case UNDER:
4565           case USING:
4566           case WHILE:
4567           case YES:
4568           case SHOW:
4569           case A:
4570           case UPDATE:
4571           case VARCHAR:
4572           case VARCHAR2:
4573           case DOUBLE:
4574           case DEC:
4575           case PRECISION:
4576           case INT:
4577           case NUMERIC:
4578           case SIGNTYPE:
4579           case NCHAR:
4580           case NVARCHAR2:
4581           case STRING:
4582           case UROWID:
4583           case VARRAY:
4584           case VARYING:
4585           case BFILE:
4586           case BLOB:
4587           case CLOB:
4588           case NCLOB:
4589           case YEAR:
4590           case LOCAL:
4591           case WITH:
4592           case ZONE:
4593           case CHARACTER:
4594           case AFTER:
4595           case BEFORE:
4596           case OLD:
4597           case PARENT:
4598           case CC_IF:
4599           case ANALYZE:
4600           case ASSOCIATE:
4601           case AUDIT:
4602           case COMPOUND:
4603           case DATABASE:
4604           case CALL:
4605           case DDL:
4606           case DISASSOCIATE:
4607           case EACH:
4608           case FOLLOWS:
4609           case LOGOFF:
4610           case LOGON:
4611           case NESTED:
4612           case NOAUDIT:
4613           case SCHEMA:
4614           case SERVERERROR:
4615           case SHUTDOWN:
4616           case STARTUP:
4617           case STATEMENT:
4618           case STATISTICS:
4619           case SUSPEND:
4620           case TRUNCATE:
4621           case WRAPPED:
4622           case LIBRARY:
4623           case NAME:
4624           case STRUCT:
4625           case CONTEXT:
4626           case PARAMETERS:
4627           case LENGTH:
4628           case TDO:
4629           case MAXLEN:
4630           case CHARSETID:
4631           case CHARSETFORM:
4632           case ACCEPT:
4633           case ACCESSIBLE:
4634           case COPY:
4635           case DEFINE:
4636           case DISCONNECT:
4637           case HOST:
4638           case PRINT:
4639           case QUIT:
4640           case REMARK:
4641           case UNDEFINE:
4642           case VARIABLE:
4643           case WHENEVER:
4644           case ATTACH:
4645           case CAST:
4646           case TREAT:
4647           case TRIM:
4648           case LEFT:
4649           case RIGHT:
4650           case BOTH:
4651           case EMPTY:
4652           case MULTISET:
4653           case SUBMULTISET:
4654           case LEADING:
4655           case TRAILING:
4656           case CHAR_CS:
4657           case NCHAR_CS:
4658           case DBTIMEZONE:
4659           case SESSIONTIMEZONE:
4660           case AUTHENTICATED:
4661           case LINK:
4662           case SHARED:
4663           case DIRECTORY:
4664           case USER:
4665           case IDENTIFIER:
4666           case QUOTED_LITERAL:
4667           case SQLDATA_CLASS:
4668           case CUSTOMDATUM_CLASS:
4669           case ORADATA_CLASS:
4670           case JAVA_INTERFACE_CLASS:
4671             DeclarativeUnit();
4672             break;
4673           case CC_ERROR:
4674             jj_consume_token(CC_ERROR);
4675             Expression();
4676             jj_consume_token(CC_END);
4677             break;
4678           default:
4679             jj_la1[41] = jj_gen;
4680             jj_consume_token(-1);
4681             throw new ParseException();
4682           }
4683         }
4684       }
4685       jj_consume_token(CC_END);
4686         jjtree.closeNodeScope(jjtn000, true);
4687         jjtc000 = false;
4688         {if (true) return jjtn000 ;}
4689     } catch (Throwable jjte000) {
4690           if (jjtc000) {
4691             jjtree.clearNodeScope(jjtn000);
4692             jjtc000 = false;
4693           } else {
4694             jjtree.popNode();
4695           }
4696           if (jjte000 instanceof RuntimeException) {
4697             {if (true) throw (RuntimeException)jjte000;}
4698           }
4699           if (jjte000 instanceof ParseException) {
4700             {if (true) throw (ParseException)jjte000;}
4701           }
4702           {if (true) throw (Error)jjte000;}
4703     } finally {
4704           if (jjtc000) {
4705             jjtree.closeNodeScope(jjtn000, true);
4706           }
4707     }
4708     throw new Error("Missing return statement in function");
4709   }
4710 
4711 /**
4712  * 2006-05-22 - Matthias Hendler - Printing of custom tag "@deprecated" removed.
4713  *                                 Printing of any custom tag added. Now user can define his own
4714  *								   custom tags which he can evaluate in the XSLT.
4715  *                                 This methode also documents global functions/procedures.
4716  */
4717   final public ASTProgramUnit ProgramUnit() throws ParseException {
4718  /*@bgen(jjtree) ProgramUnit */
4719   ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4720   boolean jjtc000 = true;
4721   jjtree.openNodeScope(jjtn000);
4722     try {
4723       switch (jj_nt.kind) {
4724       case CREATE:
4725         jj_consume_token(CREATE);
4726         switch (jj_nt.kind) {
4727         case OR:
4728           jj_consume_token(OR);
4729           jj_consume_token(REPLACE);
4730           break;
4731         default:
4732           jj_la1[42] = jj_gen;
4733           ;
4734         }
4735         switch (jj_nt.kind) {
4736         case EDITIONABLE:
4737         case NONEDITIONABLE:
4738           switch (jj_nt.kind) {
4739           case EDITIONABLE:
4740             jj_consume_token(EDITIONABLE);
4741             break;
4742           case NONEDITIONABLE:
4743             jj_consume_token(NONEDITIONABLE);
4744             break;
4745           default:
4746             jj_la1[43] = jj_gen;
4747             jj_consume_token(-1);
4748             throw new ParseException();
4749           }
4750           break;
4751         default:
4752           jj_la1[44] = jj_gen;
4753           ;
4754         }
4755         break;
4756       default:
4757         jj_la1[45] = jj_gen;
4758         ;
4759       }
4760       MethodDeclarator();
4761       switch (jj_nt.kind) {
4762       case WRAPPED:
4763         WrappedObject();
4764         break;
4765       case 4:
4766       case AGGREGATE:
4767       case AS:
4768       case AUTHID:
4769       case DETERMINISTIC:
4770       case IS:
4771       case PARALLEL_ENABLE:
4772       case PIPELINED:
4773       case RESULT_CACHE:
4774       case ACCESSIBLE:
4775         label_13:
4776         while (true) {
4777           switch (jj_nt.kind) {
4778           case AUTHID:
4779           case DETERMINISTIC:
4780           case PARALLEL_ENABLE:
4781           case PIPELINED:
4782           case RESULT_CACHE:
4783           case ACCESSIBLE:
4784             ;
4785             break;
4786           default:
4787             jj_la1[46] = jj_gen;
4788             break label_13;
4789           }
4790           switch (jj_nt.kind) {
4791           case AUTHID:
4792             jj_consume_token(AUTHID);
4793             switch (jj_nt.kind) {
4794             case CURRENT_USER:
4795               jj_consume_token(CURRENT_USER);
4796               break;
4797             case DEFINER:
4798               jj_consume_token(DEFINER);
4799               break;
4800             default:
4801               jj_la1[47] = jj_gen;
4802               jj_consume_token(-1);
4803               throw new ParseException();
4804             }
4805             break;
4806           case DETERMINISTIC:
4807             jj_consume_token(DETERMINISTIC);
4808             break;
4809           case ACCESSIBLE:
4810             AccessibleByClause();
4811             break;
4812           case PARALLEL_ENABLE:
4813             jj_consume_token(PARALLEL_ENABLE);
4814             switch (jj_nt.kind) {
4815             case 5:
4816               ParallelClause();
4817               break;
4818             default:
4819               jj_la1[48] = jj_gen;
4820               ;
4821             }
4822             switch (jj_nt.kind) {
4823             case USING:
4824               jj_consume_token(USING);
4825               ID();
4826               switch (jj_nt.kind) {
4827               case 3:
4828                 jj_consume_token(3);
4829                 ID();
4830                 break;
4831               default:
4832                 jj_la1[49] = jj_gen;
4833                 ;
4834               }
4835               break;
4836             default:
4837               jj_la1[50] = jj_gen;
4838               ;
4839             }
4840             break;
4841           case PIPELINED:
4842             jj_consume_token(PIPELINED);
4843             switch (jj_nt.kind) {
4844             case CLUSTER:
4845             case ORDER:
4846             case USING:
4847               switch (jj_nt.kind) {
4848               case USING:
4849                 jj_consume_token(USING);
4850                 ID();
4851                 switch (jj_nt.kind) {
4852                 case 3:
4853                   jj_consume_token(3);
4854                   ID();
4855                   break;
4856                 default:
4857                   jj_la1[51] = jj_gen;
4858                   ;
4859                 }
4860                 break;
4861               case CLUSTER:
4862               case ORDER:
4863                 switch (jj_nt.kind) {
4864                 case ORDER:
4865                   jj_consume_token(ORDER);
4866                   break;
4867                 case CLUSTER:
4868                   jj_consume_token(CLUSTER);
4869                   break;
4870                 default:
4871                   jj_la1[52] = jj_gen;
4872                   jj_consume_token(-1);
4873                   throw new ParseException();
4874                 }
4875                 switch (jj_nt.kind) {
4876                 case REPLACE:
4877                 case DEFINER:
4878                 case CURRENT_USER:
4879                 case SERIALLY_REUSABLE:
4880                 case RESTRICT_REFERENCES:
4881                 case EXCEPTION_INIT:
4882                 case AUTONOMOUS_TRANSACTION:
4883                 case LANGUAGE:
4884                 case INLINE:
4885                 case ADD:
4886                 case AGGREGATE:
4887                 case ALL:
4888                 case ALTER:
4889                 case AND:
4890                 case ANY:
4891                 case ARRAY:
4892                 case AS:
4893                 case ASC:
4894                 case AT:
4895                 case ATTRIBUTE:
4896                 case AUTHID:
4897                 case AVG:
4898                 case BETWEEN:
4899                 case BINARY_INTEGER:
4900                 case BODY:
4901                 case BOOLEAN:
4902                 case BULK:
4903                 case BY:
4904                 case BYTE:
4905                 case CASCADE:
4906                 case CASE:
4907                 case CHAR:
4908                 case CHAR_BASE:
4909                 case CHECK:
4910                 case CLOSE:
4911                 case CLUSTER:
4912                 case COALESCE:
4913                 case COLLECT:
4914                 case COLUMN:
4915                 case COMMENT:
4916                 case COMMIT:
4917                 case COMPRESS:
4918                 case CONNECT:
4919                 case CONSTANT:
4920                 case CONSTRUCTOR:
4921                 case CONTINUE:
4922                 case CONVERT:
4923                 case CREATE:
4924                 case CURRENT:
4925                 case CURRVAL:
4926                 case CURSOR:
4927                 case DATA:
4928                 case DATE:
4929                 case DAY:
4930                 case DECLARE:
4931                 case DECIMAL:
4932                 case _DEFAULT:
4933                 case DELETE:
4934                 case DESC:
4935                 case DISABLE:
4936                 case DISTINCT:
4937                 case DO:
4938                 case DROP:
4939                 case EDITIONABLE:
4940                 case ELEMENT:
4941                 case ELSE:
4942                 case ELSIF:
4943                 case ENABLE:
4944                 case ESCAPE:
4945                 case EXCEPT:
4946                 case EXCEPTION:
4947                 case EXCEPTIONS:
4948                 case EXCLUSIVE:
4949                 case EXECUTE:
4950                 case EXISTS:
4951                 case EXIT:
4952                 case EXTERNAL:
4953                 case EXTENDS:
4954                 case EXTRACT:
4955                 case FALSE:
4956                 case FETCH:
4957                 case FINAL:
4958                 case FLOAT:
4959                 case FOR:
4960                 case FORALL:
4961                 case FORCE:
4962                 case FROM:
4963                 case FUNCTION:
4964                 case GLOBAL:
4965                 case GOTO:
4966                 case GROUP:
4967                 case HASH:
4968                 case HAVING:
4969                 case HEAP:
4970                 case HOUR:
4971                 case IF:
4972                 case IMMEDIATE:
4973                 case IN:
4974                 case INDEX:
4975                 case INDICES:
4976                 case INDEXTYPE:
4977                 case INDICATOR:
4978                 case INSERT:
4979                 case INSTANTIABLE:
4980                 case INTEGER:
4981                 case INTERFACE:
4982                 case INTERSECT:
4983                 case INTERVAL:
4984                 case INTO:
4985                 case INVALIDATE:
4986                 case IS:
4987                 case ISOLATION:
4988                 case JAVA:
4989                 case LEVEL:
4990                 case LIKE:
4991                 case LIMIT:
4992                 case LIMITED:
4993                 case LOCK:
4994                 case LONG:
4995                 case LOOP:
4996                 case MAP:
4997                 case MAX:
4998                 case MEMBER:
4999                 case MERGE:
5000                 case MIN:
5001                 case MINUS:
5002                 case MINUTE:
5003                 case MLSLABEL:
5004                 case MODIFY:
5005                 case MOD:
5006                 case MODE:
5007                 case MONTH:
5008                 case NATURAL:
5009                 case NATURALN:
5010                 case NEW:
5011                 case NEXTVAL:
5012                 case NO:
5013                 case NOCOPY:
5014                 case NONEDITIONABLE:
5015                 case NOT:
5016                 case NOWAIT:
5017                 case NULL:
5018                 case NULLIF:
5019                 case NUMBER:
5020                 case BFILE_BASE:
5021                 case BLOB_BASE:
5022                 case CLOB_BASE:
5023                 case DATE_BASE:
5024                 case NUMBER_BASE:
5025                 case OBJECT:
5026                 case OCIROWID:
5027                 case OF:
5028                 case OID:
5029                 case ON:
5030                 case OPAQUE:
5031                 case OPEN:
5032                 case OPERATOR:
5033                 case OPTION:
5034                 case OR:
5035                 case ORDER:
5036                 case ORGANIZATION:
5037                 case OTHERS:
5038                 case OUT:
5039                 case OVERRIDING:
5040                 case PACKAGE:
5041                 case PARTITION:
5042                 case PCTFREE:
5043                 case PLS_INTEGER:
5044                 case POSITIVE:
5045                 case POSITIVEN:
5046                 case PRESERVE:
5047                 case PRIOR:
5048                 case PROMPT:
5049                 case PRIVATE:
5050                 case PROCEDURE:
5051                 case PUBLIC:
5052                 case RAISE:
5053                 case RANGE:
5054                 case RAW:
5055                 case REAL:
5056                 case RECORD:
5057                 case REF:
5058                 case RELEASE:
5059                 case RELIES_ON:
5060                 case RENAME:
5061                 case RESULT:
5062                 case RETURN:
5063                 case RETURNING:
5064                 case REVERSE:
5065                 case ROLLBACK:
5066                 case ROW:
5067                 case ROWS:
5068                 case ROWID:
5069                 case ROWNUM:
5070                 case ROWTYPE:
5071                 case SAVE:
5072                 case SAVEPOINT:
5073                 case SECOND:
5074                 case SELECT:
5075                 case SELF:
5076                 case SEPARATE:
5077                 case SET:
5078                 case SHARE:
5079                 case SMALLINT:
5080                 case SPACE:
5081                 case SQL:
5082                 case SQLCODE:
5083                 case SQLERRM:
5084                 case START:
5085                 case STATIC:
5086                 case STDDEV:
5087                 case SUBTYPE:
5088                 case SUBSTITUTABLE:
5089                 case SUCCESSFUL:
5090                 case SUM:
5091                 case SYNONYM:
5092                 case SYSDATE:
5093                 case SYS_REFCURSOR:
5094                 case TABLE:
5095                 case TEMPORARY:
5096                 case THEN:
5097                 case TIME:
5098                 case TIMESTAMP:
5099                 case TIMEZONE_REGION:
5100                 case TIMEZONE_ABBR:
5101                 case TIMEZONE_MINUTE:
5102                 case TIMEZONE_HOUR:
5103                 case TO:
5104                 case TRANSACTION:
5105                 case TRIGGER:
5106                 case TRUE:
5107                 case TYPE:
5108                 case UI:
5109                 case UNDER:
5110                 case USING:
5111                 case WHILE:
5112                 case YES:
5113                 case SHOW:
5114                 case A:
5115                 case UPDATE:
5116                 case VARCHAR:
5117                 case VARCHAR2:
5118                 case DOUBLE:
5119                 case DEC:
5120                 case PRECISION:
5121                 case INT:
5122                 case NUMERIC:
5123                 case SIGNTYPE:
5124                 case NCHAR:
5125                 case NVARCHAR2:
5126                 case STRING:
5127                 case UROWID:
5128                 case VARRAY:
5129                 case VARYING:
5130                 case BFILE:
5131                 case BLOB:
5132                 case CLOB:
5133                 case NCLOB:
5134                 case YEAR:
5135                 case LOCAL:
5136                 case WITH:
5137                 case ZONE:
5138                 case CHARACTER:
5139                 case AFTER:
5140                 case BEFORE:
5141                 case OLD:
5142                 case PARENT:
5143                 case ANALYZE:
5144                 case ASSOCIATE:
5145                 case AUDIT:
5146                 case COMPOUND:
5147                 case DATABASE:
5148                 case CALL:
5149                 case DDL:
5150                 case DISASSOCIATE:
5151                 case EACH:
5152                 case FOLLOWS:
5153                 case LOGOFF:
5154                 case LOGON:
5155                 case NESTED:
5156                 case NOAUDIT:
5157                 case SCHEMA:
5158                 case SERVERERROR:
5159                 case SHUTDOWN:
5160                 case STARTUP:
5161                 case STATEMENT:
5162                 case STATISTICS:
5163                 case SUSPEND:
5164                 case TRUNCATE:
5165                 case WRAPPED:
5166                 case LIBRARY:
5167                 case NAME:
5168                 case STRUCT:
5169                 case CONTEXT:
5170                 case PARAMETERS:
5171                 case LENGTH:
5172                 case TDO:
5173                 case MAXLEN:
5174                 case CHARSETID:
5175                 case CHARSETFORM:
5176                 case ACCEPT:
5177                 case ACCESSIBLE:
5178                 case COPY:
5179                 case DEFINE:
5180                 case DISCONNECT:
5181                 case HOST:
5182                 case PRINT:
5183                 case QUIT:
5184                 case REMARK:
5185                 case UNDEFINE:
5186                 case VARIABLE:
5187                 case WHENEVER:
5188                 case ATTACH:
5189                 case CAST:
5190                 case TREAT:
5191                 case TRIM:
5192                 case LEFT:
5193                 case RIGHT:
5194                 case BOTH:
5195                 case EMPTY:
5196                 case MULTISET:
5197                 case SUBMULTISET:
5198                 case LEADING:
5199                 case TRAILING:
5200                 case CHAR_CS:
5201                 case NCHAR_CS:
5202                 case DBTIMEZONE:
5203                 case SESSIONTIMEZONE:
5204                 case AUTHENTICATED:
5205                 case LINK:
5206                 case SHARED:
5207                 case DIRECTORY:
5208                 case USER:
5209                 case IDENTIFIER:
5210                 case QUOTED_LITERAL:
5211                 case SQLDATA_CLASS:
5212                 case CUSTOMDATUM_CLASS:
5213                 case ORADATA_CLASS:
5214                 case JAVA_INTERFACE_CLASS:
5215                   ID();
5216                   break;
5217                 default:
5218                   jj_la1[53] = jj_gen;
5219                   ;
5220                 }
5221                 jj_consume_token(BY);
5222                 jj_consume_token(5);
5223                 ID();
5224                 label_14:
5225                 while (true) {
5226                   switch (jj_nt.kind) {
5227                   case 6:
5228                     ;
5229                     break;
5230                   default:
5231                     jj_la1[54] = jj_gen;
5232                     break label_14;
5233                   }
5234                   jj_consume_token(6);
5235                   ID();
5236                 }
5237                 jj_consume_token(7);
5238                 break;
5239               default:
5240                 jj_la1[55] = jj_gen;
5241                 jj_consume_token(-1);
5242                 throw new ParseException();
5243               }
5244               break;
5245             default:
5246               jj_la1[56] = jj_gen;
5247               ;
5248             }
5249             break;
5250           case RESULT_CACHE:
5251             jj_consume_token(RESULT_CACHE);
5252             switch (jj_nt.kind) {
5253             case RELIES_ON:
5254               jj_consume_token(RELIES_ON);
5255               jj_consume_token(5);
5256               ID();
5257               switch (jj_nt.kind) {
5258               case 3:
5259                 jj_consume_token(3);
5260                 ID();
5261                 break;
5262               default:
5263                 jj_la1[57] = jj_gen;
5264                 ;
5265               }
5266               label_15:
5267               while (true) {
5268                 switch (jj_nt.kind) {
5269                 case 6:
5270                   ;
5271                   break;
5272                 default:
5273                   jj_la1[58] = jj_gen;
5274                   break label_15;
5275                 }
5276                 jj_consume_token(6);
5277                 ID();
5278                 switch (jj_nt.kind) {
5279                 case 3:
5280                   jj_consume_token(3);
5281                   ID();
5282                   break;
5283                 default:
5284                   jj_la1[59] = jj_gen;
5285                   ;
5286                 }
5287               }
5288               jj_consume_token(7);
5289               break;
5290             default:
5291               jj_la1[60] = jj_gen;
5292               ;
5293             }
5294             break;
5295           default:
5296             jj_la1[61] = jj_gen;
5297             jj_consume_token(-1);
5298             throw new ParseException();
5299           }
5300         }
5301         switch (jj_nt.kind) {
5302         case AGGREGATE:
5303           jj_consume_token(AGGREGATE);
5304           jj_consume_token(USING);
5305           ID();
5306           break;
5307         default:
5308           jj_la1[62] = jj_gen;
5309           ;
5310         }
5311         switch (jj_nt.kind) {
5312         case AS:
5313         case IS:
5314           switch (jj_nt.kind) {
5315           case IS:
5316             jj_consume_token(IS);
5317             break;
5318           case AS:
5319             jj_consume_token(AS);
5320             break;
5321           default:
5322             jj_la1[63] = jj_gen;
5323             jj_consume_token(-1);
5324             throw new ParseException();
5325           }
5326           if (jj_2_21(2)) {
5327             CallSpecTail();
5328           } else {
5329             switch (jj_nt.kind) {
5330             case REPLACE:
5331             case DEFINER:
5332             case CURRENT_USER:
5333             case SERIALLY_REUSABLE:
5334             case RESTRICT_REFERENCES:
5335             case EXCEPTION_INIT:
5336             case AUTONOMOUS_TRANSACTION:
5337             case LANGUAGE:
5338             case INLINE:
5339             case ADD:
5340             case AGGREGATE:
5341             case ALL:
5342             case ALTER:
5343             case AND:
5344             case ANY:
5345             case ARRAY:
5346             case AS:
5347             case ASC:
5348             case AT:
5349             case ATTRIBUTE:
5350             case AUTHID:
5351             case AVG:
5352             case BEGIN:
5353             case BETWEEN:
5354             case BINARY_INTEGER:
5355             case BODY:
5356             case BOOLEAN:
5357             case BULK:
5358             case BY:
5359             case BYTE:
5360             case CASCADE:
5361             case CASE:
5362             case CHAR:
5363             case CHAR_BASE:
5364             case CHECK:
5365             case CLOSE:
5366             case CLUSTER:
5367             case COALESCE:
5368             case COLLECT:
5369             case COLUMN:
5370             case COMMENT:
5371             case COMMIT:
5372             case COMPRESS:
5373             case CONNECT:
5374             case CONSTANT:
5375             case CONSTRUCTOR:
5376             case CONTINUE:
5377             case CONVERT:
5378             case CREATE:
5379             case CURRENT:
5380             case CURRVAL:
5381             case CURSOR:
5382             case DATA:
5383             case DATE:
5384             case DAY:
5385             case DECLARE:
5386             case DECIMAL:
5387             case _DEFAULT:
5388             case DELETE:
5389             case DESC:
5390             case DISABLE:
5391             case DISTINCT:
5392             case DO:
5393             case DROP:
5394             case EDITIONABLE:
5395             case ELEMENT:
5396             case ELSE:
5397             case ELSIF:
5398             case ENABLE:
5399             case ESCAPE:
5400             case EXCEPT:
5401             case EXCEPTION:
5402             case EXCEPTIONS:
5403             case EXCLUSIVE:
5404             case EXECUTE:
5405             case EXISTS:
5406             case EXIT:
5407             case EXTERNAL:
5408             case EXTENDS:
5409             case EXTRACT:
5410             case FALSE:
5411             case FETCH:
5412             case FINAL:
5413             case FLOAT:
5414             case FOR:
5415             case FORALL:
5416             case FORCE:
5417             case FROM:
5418             case FUNCTION:
5419             case GLOBAL:
5420             case GOTO:
5421             case GROUP:
5422             case HASH:
5423             case HAVING:
5424             case HEAP:
5425             case HOUR:
5426             case IF:
5427             case IMMEDIATE:
5428             case IN:
5429             case INDEX:
5430             case INDICES:
5431             case INDEXTYPE:
5432             case INDICATOR:
5433             case INSERT:
5434             case INSTANTIABLE:
5435             case INTEGER:
5436             case INTERFACE:
5437             case INTERSECT:
5438             case INTERVAL:
5439             case INTO:
5440             case INVALIDATE:
5441             case IS:
5442             case ISOLATION:
5443             case JAVA:
5444             case LEVEL:
5445             case LIKE:
5446             case LIMIT:
5447             case LIMITED:
5448             case LOCK:
5449             case LONG:
5450             case LOOP:
5451             case MAP:
5452             case MAX:
5453             case MEMBER:
5454             case MERGE:
5455             case MIN:
5456             case MINUS:
5457             case MINUTE:
5458             case MLSLABEL:
5459             case MODIFY:
5460             case MOD:
5461             case MODE:
5462             case MONTH:
5463             case NATURAL:
5464             case NATURALN:
5465             case NEW:
5466             case NEXTVAL:
5467             case NO:
5468             case NOCOPY:
5469             case NONEDITIONABLE:
5470             case NOT:
5471             case NOWAIT:
5472             case NULL:
5473             case NULLIF:
5474             case NUMBER:
5475             case BFILE_BASE:
5476             case BLOB_BASE:
5477             case CLOB_BASE:
5478             case DATE_BASE:
5479             case NUMBER_BASE:
5480             case OBJECT:
5481             case OCIROWID:
5482             case OF:
5483             case OID:
5484             case ON:
5485             case OPAQUE:
5486             case OPEN:
5487             case OPERATOR:
5488             case OPTION:
5489             case OR:
5490             case ORDER:
5491             case ORGANIZATION:
5492             case OTHERS:
5493             case OUT:
5494             case OVERRIDING:
5495             case PACKAGE:
5496             case PARTITION:
5497             case PCTFREE:
5498             case PLS_INTEGER:
5499             case POSITIVE:
5500             case POSITIVEN:
5501             case PRAGMA:
5502             case PRESERVE:
5503             case PRIOR:
5504             case PROMPT:
5505             case PRIVATE:
5506             case PROCEDURE:
5507             case PUBLIC:
5508             case RAISE:
5509             case RANGE:
5510             case RAW:
5511             case REAL:
5512             case RECORD:
5513             case REF:
5514             case RELEASE:
5515             case RELIES_ON:
5516             case RENAME:
5517             case RESULT:
5518             case RETURN:
5519             case RETURNING:
5520             case REVERSE:
5521             case ROLLBACK:
5522             case ROW:
5523             case ROWS:
5524             case ROWID:
5525             case ROWNUM:
5526             case ROWTYPE:
5527             case SAVE:
5528             case SAVEPOINT:
5529             case SECOND:
5530             case SELECT:
5531             case SELF:
5532             case SEPARATE:
5533             case SET:
5534             case SHARE:
5535             case SMALLINT:
5536             case SPACE:
5537             case SQL:
5538             case SQLCODE:
5539             case SQLERRM:
5540             case START:
5541             case STATIC:
5542             case STDDEV:
5543             case SUBTYPE:
5544             case SUBSTITUTABLE:
5545             case SUCCESSFUL:
5546             case SUM:
5547             case SYNONYM:
5548             case SYSDATE:
5549             case SYS_REFCURSOR:
5550             case TABLE:
5551             case TEMPORARY:
5552             case THEN:
5553             case TIME:
5554             case TIMESTAMP:
5555             case TIMEZONE_REGION:
5556             case TIMEZONE_ABBR:
5557             case TIMEZONE_MINUTE:
5558             case TIMEZONE_HOUR:
5559             case TO:
5560             case TRANSACTION:
5561             case TRIGGER:
5562             case TRUE:
5563             case TYPE:
5564             case UI:
5565             case UNDER:
5566             case USING:
5567             case WHILE:
5568             case YES:
5569             case SHOW:
5570             case A:
5571             case UPDATE:
5572             case VARCHAR:
5573             case VARCHAR2:
5574             case DOUBLE:
5575             case DEC:
5576             case PRECISION:
5577             case INT:
5578             case NUMERIC:
5579             case SIGNTYPE:
5580             case NCHAR:
5581             case NVARCHAR2:
5582             case STRING:
5583             case UROWID:
5584             case VARRAY:
5585             case VARYING:
5586             case BFILE:
5587             case BLOB:
5588             case CLOB:
5589             case NCLOB:
5590             case YEAR:
5591             case LOCAL:
5592             case WITH:
5593             case ZONE:
5594             case CHARACTER:
5595             case AFTER:
5596             case BEFORE:
5597             case OLD:
5598             case PARENT:
5599             case CC_IF:
5600             case ANALYZE:
5601             case ASSOCIATE:
5602             case AUDIT:
5603             case COMPOUND:
5604             case DATABASE:
5605             case CALL:
5606             case DDL:
5607             case DISASSOCIATE:
5608             case EACH:
5609             case FOLLOWS:
5610             case LOGOFF:
5611             case LOGON:
5612             case NESTED:
5613             case NOAUDIT:
5614             case SCHEMA:
5615             case SERVERERROR:
5616             case SHUTDOWN:
5617             case STARTUP:
5618             case STATEMENT:
5619             case STATISTICS:
5620             case SUSPEND:
5621             case TRUNCATE:
5622             case WRAPPED:
5623             case LIBRARY:
5624             case NAME:
5625             case STRUCT:
5626             case CONTEXT:
5627             case PARAMETERS:
5628             case LENGTH:
5629             case TDO:
5630             case MAXLEN:
5631             case CHARSETID:
5632             case CHARSETFORM:
5633             case ACCEPT:
5634             case ACCESSIBLE:
5635             case COPY:
5636             case DEFINE:
5637             case DISCONNECT:
5638             case HOST:
5639             case PRINT:
5640             case QUIT:
5641             case REMARK:
5642             case UNDEFINE:
5643             case VARIABLE:
5644             case WHENEVER:
5645             case ATTACH:
5646             case CAST:
5647             case TREAT:
5648             case TRIM:
5649             case LEFT:
5650             case RIGHT:
5651             case BOTH:
5652             case EMPTY:
5653             case MULTISET:
5654             case SUBMULTISET:
5655             case LEADING:
5656             case TRAILING:
5657             case CHAR_CS:
5658             case NCHAR_CS:
5659             case DBTIMEZONE:
5660             case SESSIONTIMEZONE:
5661             case AUTHENTICATED:
5662             case LINK:
5663             case SHARED:
5664             case DIRECTORY:
5665             case USER:
5666             case IDENTIFIER:
5667             case QUOTED_LITERAL:
5668             case SQLDATA_CLASS:
5669             case CUSTOMDATUM_CLASS:
5670             case ORADATA_CLASS:
5671             case JAVA_INTERFACE_CLASS:
5672               DeclarativeSection();
5673               jj_consume_token(BEGIN);
5674               switch (jj_nt.kind) {
5675               case PRAGMA:
5676                 Pragma();
5677                 break;
5678               default:
5679                 jj_la1[64] = jj_gen;
5680                 ;
5681               }
5682               label_16:
5683               while (true) {
5684                 switch (jj_nt.kind) {
5685                 case 5:
5686                 case 16:
5687                 case 17:
5688                 case 21:
5689                 case REPLACE:
5690                 case DEFINER:
5691                 case CURRENT_USER:
5692                 case LANGUAGE:
5693                 case INLINE:
5694                 case ADD:
5695                 case AGGREGATE:
5696                 case ARRAY:
5697                 case AT:
5698                 case ATTRIBUTE:
5699                 case AUTHID:
5700                 case BEGIN:
5701                 case BODY:
5702                 case BULK:
5703                 case BYTE:
5704                 case CASCADE:
5705                 case CASE:
5706                 case CLOSE:
5707                 case COALESCE:
5708                 case COLLECT:
5709                 case COLUMN:
5710                 case COMMENT:
5711                 case COMMIT:
5712                 case CONSTRUCTOR:
5713                 case CONTINUE:
5714                 case CONVERT:
5715                 case CURRENT:
5716                 case CURSOR:
5717                 case DATA:
5718                 case DATE:
5719                 case DAY:
5720                 case DECLARE:
5721                 case DELETE:
5722                 case DISABLE:
5723                 case EDITIONABLE:
5724                 case ELEMENT:
5725                 case ENABLE:
5726                 case ESCAPE:
5727                 case EXCEPT:
5728                 case EXCEPTIONS:
5729                 case EXECUTE:
5730                 case EXIT:
5731                 case EXTERNAL:
5732                 case EXTENDS:
5733                 case EXTRACT:
5734                 case FALSE:
5735                 case FETCH:
5736                 case FINAL:
5737                 case FOR:
5738                 case FORALL:
5739                 case FORCE:
5740                 case FUNCTION:
5741                 case GLOBAL:
5742                 case GOTO:
5743                 case HASH:
5744                 case HEAP:
5745                 case HOUR:
5746                 case IF:
5747                 case IMMEDIATE:
5748                 case INDICES:
5749                 case INDEXTYPE:
5750                 case INDICATOR:
5751                 case INSERT:
5752                 case INSTANTIABLE:
5753                 case INTERVAL:
5754                 case INVALIDATE:
5755                 case ISOLATION:
5756                 case JAVA:
5757                 case LEVEL:
5758                 case LIMIT:
5759                 case LOCK:
5760                 case LOOP:
5761                 case MAP:
5762                 case MAX:
5763                 case MEMBER:
5764                 case MERGE:
5765                 case MIN:
5766                 case MINUTE:
5767                 case MLSLABEL:
5768                 case MODIFY:
5769                 case MOD:
5770                 case MONTH:
5771                 case NATURAL:
5772                 case NEW:
5773                 case NEW_DOT:
5774                 case NO:
5775                 case NONEDITIONABLE:
5776                 case NOT:
5777                 case NULL:
5778                 case NULLIF:
5779                 case OBJECT:
5780                 case OID:
5781                 case OPAQUE:
5782                 case OPEN:
5783                 case OPERATOR:
5784                 case ORGANIZATION:
5785                 case OTHERS:
5786                 case OVERRIDING:
5787                 case PACKAGE:
5788                 case PARTITION:
5789                 case PIPE:
5790                 case PRAGMA:
5791                 case PRESERVE:
5792                 case PRIVATE:
5793                 case PROCEDURE:
5794                 case RAISE:
5795                 case RANGE:
5796                 case RAW:
5797                 case REAL:
5798                 case RECORD:
5799                 case REF:
5800                 case RELEASE:
5801                 case RELIES_ON:
5802                 case RENAME:
5803                 case RESULT:
5804                 case RETURN:
5805                 case RETURNING:
5806                 case REVERSE:
5807                 case ROLLBACK:
5808                 case ROW:
5809                 case ROWS:
5810                 case ROWID:
5811                 case ROWNUM:
5812                 case SAVE:
5813                 case SAVEPOINT:
5814                 case SECOND:
5815                 case SELECT:
5816                 case SELF:
5817                 case SET:
5818                 case SPACE:
5819                 case SQL:
5820                 case SQLCODE:
5821                 case SQLERRM:
5822                 case STATIC:
5823                 case SUBTYPE:
5824                 case SUBSTITUTABLE:
5825                 case SUCCESSFUL:
5826                 case SYSDATE:
5827                 case SYS_REFCURSOR:
5828                 case TEMPORARY:
5829                 case TIME:
5830                 case TIMESTAMP:
5831                 case TIMEZONE_REGION:
5832                 case TIMEZONE_ABBR:
5833                 case TIMEZONE_MINUTE:
5834                 case TIMEZONE_HOUR:
5835                 case TRANSACTION:
5836                 case TRUE:
5837                 case TYPE:
5838                 case UNDER:
5839                 case USING:
5840                 case WHILE:
5841                 case YES:
5842                 case SHOW:
5843                 case A:
5844                 case UPDATE:
5845                 case DOUBLE:
5846                 case DEC:
5847                 case PRECISION:
5848                 case INT:
5849                 case NUMERIC:
5850                 case NCHAR:
5851                 case NVARCHAR2:
5852                 case STRING:
5853                 case UROWID:
5854                 case VARRAY:
5855                 case VARYING:
5856                 case BFILE:
5857                 case BLOB:
5858                 case CLOB:
5859                 case NCLOB:
5860                 case YEAR:
5861                 case LOCAL:
5862                 case WITH:
5863                 case ZONE:
5864                 case CHARACTER:
5865                 case AFTER:
5866                 case BEFORE:
5867                 case OLD:
5868                 case PARENT:
5869                 case CC_IF:
5870                 case CC_ERROR:
5871                 case ANALYZE:
5872                 case ASSOCIATE:
5873                 case AUDIT:
5874                 case COMPOUND:
5875                 case DATABASE:
5876                 case CALL:
5877                 case DDL:
5878                 case DISASSOCIATE:
5879                 case EACH:
5880                 case FOLLOWS:
5881                 case LOGOFF:
5882                 case LOGON:
5883                 case NESTED:
5884                 case NOAUDIT:
5885                 case SCHEMA:
5886                 case SERVERERROR:
5887                 case SHUTDOWN:
5888                 case STARTUP:
5889                 case STATEMENT:
5890                 case STATISTICS:
5891                 case SUSPEND:
5892                 case TRUNCATE:
5893                 case WRAPPED:
5894                 case LIBRARY:
5895                 case NAME:
5896                 case STRUCT:
5897                 case CONTEXT:
5898                 case PARAMETERS:
5899                 case LENGTH:
5900                 case TDO:
5901                 case MAXLEN:
5902                 case CHARSETID:
5903                 case CHARSETFORM:
5904                 case ACCEPT:
5905                 case ACCESSIBLE:
5906                 case COPY:
5907                 case DEFINE:
5908                 case DISCONNECT:
5909                 case HOST:
5910                 case PRINT:
5911                 case QUIT:
5912                 case REMARK:
5913                 case UNDEFINE:
5914                 case VARIABLE:
5915                 case WHENEVER:
5916                 case ATTACH:
5917                 case CAST:
5918                 case TREAT:
5919                 case TRIM:
5920                 case LEFT:
5921                 case RIGHT:
5922                 case BOTH:
5923                 case EMPTY:
5924                 case MULTISET:
5925                 case SUBMULTISET:
5926                 case LEADING:
5927                 case TRAILING:
5928                 case CHAR_CS:
5929                 case NCHAR_CS:
5930                 case DBTIMEZONE:
5931                 case SESSIONTIMEZONE:
5932                 case AUTHENTICATED:
5933                 case LINK:
5934                 case SHARED:
5935                 case DIRECTORY:
5936                 case USER:
5937                 case IDENTIFIER:
5938                 case UNSIGNED_NUMERIC_LITERAL:
5939                 case CHARACTER_LITERAL:
5940                 case STRING_LITERAL:
5941                 case QUOTED_LITERAL:
5942                   ;
5943                   break;
5944                 default:
5945                   jj_la1[65] = jj_gen;
5946                   break label_16;
5947                 }
5948                 Statement();
5949               }
5950               switch (jj_nt.kind) {
5951               case EXCEPTION:
5952                 ExceptionHandler();
5953                 break;
5954               default:
5955                 jj_la1[66] = jj_gen;
5956                 ;
5957               }
5958               jj_consume_token(END);
5959               switch (jj_nt.kind) {
5960               case REPLACE:
5961               case DEFINER:
5962               case CURRENT_USER:
5963               case SERIALLY_REUSABLE:
5964               case RESTRICT_REFERENCES:
5965               case EXCEPTION_INIT:
5966               case AUTONOMOUS_TRANSACTION:
5967               case LANGUAGE:
5968               case INLINE:
5969               case ADD:
5970               case AGGREGATE:
5971               case ALL:
5972               case ALTER:
5973               case AND:
5974               case ANY:
5975               case ARRAY:
5976               case AS:
5977               case ASC:
5978               case AT:
5979               case ATTRIBUTE:
5980               case AUTHID:
5981               case AVG:
5982               case BETWEEN:
5983               case BINARY_INTEGER:
5984               case BODY:
5985               case BOOLEAN:
5986               case BULK:
5987               case BY:
5988               case BYTE:
5989               case CASCADE:
5990               case CASE:
5991               case CHAR:
5992               case CHAR_BASE:
5993               case CHECK:
5994               case CLOSE:
5995               case CLUSTER:
5996               case COALESCE:
5997               case COLLECT:
5998               case COLUMN:
5999               case COMMENT:
6000               case COMMIT:
6001               case COMPRESS:
6002               case CONNECT:
6003               case CONSTANT:
6004               case CONSTRUCTOR:
6005               case CONTINUE:
6006               case CONVERT:
6007               case CREATE:
6008               case CURRENT:
6009               case CURRVAL:
6010               case CURSOR:
6011               case DATA:
6012               case DATE:
6013               case DAY:
6014               case DECLARE:
6015               case DECIMAL:
6016               case _DEFAULT:
6017               case DELETE:
6018               case DESC:
6019               case DISABLE:
6020               case DISTINCT:
6021               case DO:
6022               case DROP:
6023               case EDITIONABLE:
6024               case ELEMENT:
6025               case ELSE:
6026               case ELSIF:
6027               case ENABLE:
6028               case ESCAPE:
6029               case EXCEPT:
6030               case EXCEPTION:
6031               case EXCEPTIONS:
6032               case EXCLUSIVE:
6033               case EXECUTE:
6034               case EXISTS:
6035               case EXIT:
6036               case EXTERNAL:
6037               case EXTENDS:
6038               case EXTRACT:
6039               case FALSE:
6040               case FETCH:
6041               case FINAL:
6042               case FLOAT:
6043               case FOR:
6044               case FORALL:
6045               case FORCE:
6046               case FROM:
6047               case FUNCTION:
6048               case GLOBAL:
6049               case GOTO:
6050               case GROUP:
6051               case HASH:
6052               case HAVING:
6053               case HEAP:
6054               case HOUR:
6055               case IF:
6056               case IMMEDIATE:
6057               case IN:
6058               case INDEX:
6059               case INDICES:
6060               case INDEXTYPE:
6061               case INDICATOR:
6062               case INSERT:
6063               case INSTANTIABLE:
6064               case INTEGER:
6065               case INTERFACE:
6066               case INTERSECT:
6067               case INTERVAL:
6068               case INTO:
6069               case INVALIDATE:
6070               case IS:
6071               case ISOLATION:
6072               case JAVA:
6073               case LEVEL:
6074               case LIKE:
6075               case LIMIT:
6076               case LIMITED:
6077               case LOCK:
6078               case LONG:
6079               case LOOP:
6080               case MAP:
6081               case MAX:
6082               case MEMBER:
6083               case MERGE:
6084               case MIN:
6085               case MINUS:
6086               case MINUTE:
6087               case MLSLABEL:
6088               case MODIFY:
6089               case MOD:
6090               case MODE:
6091               case MONTH:
6092               case NATURAL:
6093               case NATURALN:
6094               case NEW:
6095               case NEXTVAL:
6096               case NO:
6097               case NOCOPY:
6098               case NONEDITIONABLE:
6099               case NOT:
6100               case NOWAIT:
6101               case NULL:
6102               case NULLIF:
6103               case NUMBER:
6104               case BFILE_BASE:
6105               case BLOB_BASE:
6106               case CLOB_BASE:
6107               case DATE_BASE:
6108               case NUMBER_BASE:
6109               case OBJECT:
6110               case OCIROWID:
6111               case OF:
6112               case OID:
6113               case ON:
6114               case OPAQUE:
6115               case OPEN:
6116               case OPERATOR:
6117               case OPTION:
6118               case OR:
6119               case ORDER:
6120               case ORGANIZATION:
6121               case OTHERS:
6122               case OUT:
6123               case OVERRIDING:
6124               case PACKAGE:
6125               case PARTITION:
6126               case PCTFREE:
6127               case PLS_INTEGER:
6128               case POSITIVE:
6129               case POSITIVEN:
6130               case PRESERVE:
6131               case PRIOR:
6132               case PROMPT:
6133               case PRIVATE:
6134               case PROCEDURE:
6135               case PUBLIC:
6136               case RAISE:
6137               case RANGE:
6138               case RAW:
6139               case REAL:
6140               case RECORD:
6141               case REF:
6142               case RELEASE:
6143               case RELIES_ON:
6144               case RENAME:
6145               case RESULT:
6146               case RETURN:
6147               case RETURNING:
6148               case REVERSE:
6149               case ROLLBACK:
6150               case ROW:
6151               case ROWS:
6152               case ROWID:
6153               case ROWNUM:
6154               case ROWTYPE:
6155               case SAVE:
6156               case SAVEPOINT:
6157               case SECOND:
6158               case SELECT:
6159               case SELF:
6160               case SEPARATE:
6161               case SET:
6162               case SHARE:
6163               case SMALLINT:
6164               case SPACE:
6165               case SQL:
6166               case SQLCODE:
6167               case SQLERRM:
6168               case START:
6169               case STATIC:
6170               case STDDEV:
6171               case SUBTYPE:
6172               case SUBSTITUTABLE:
6173               case SUCCESSFUL:
6174               case SUM:
6175               case SYNONYM:
6176               case SYSDATE:
6177               case SYS_REFCURSOR:
6178               case TABLE:
6179               case TEMPORARY:
6180               case THEN:
6181               case TIME:
6182               case TIMESTAMP:
6183               case TIMEZONE_REGION:
6184               case TIMEZONE_ABBR:
6185               case TIMEZONE_MINUTE:
6186               case TIMEZONE_HOUR:
6187               case TO:
6188               case TRANSACTION:
6189               case TRIGGER:
6190               case TRUE:
6191               case TYPE:
6192               case UI:
6193               case UNDER:
6194               case USING:
6195               case WHILE:
6196               case YES:
6197               case SHOW:
6198               case A:
6199               case UPDATE:
6200               case VARCHAR:
6201               case VARCHAR2:
6202               case DOUBLE:
6203               case DEC:
6204               case PRECISION:
6205               case INT:
6206               case NUMERIC:
6207               case SIGNTYPE:
6208               case NCHAR:
6209               case NVARCHAR2:
6210               case STRING:
6211               case UROWID:
6212               case VARRAY:
6213               case VARYING:
6214               case BFILE:
6215               case BLOB:
6216               case CLOB:
6217               case NCLOB:
6218               case YEAR:
6219               case LOCAL:
6220               case WITH:
6221               case ZONE:
6222               case CHARACTER:
6223               case AFTER:
6224               case BEFORE:
6225               case OLD:
6226               case PARENT:
6227               case ANALYZE:
6228               case ASSOCIATE:
6229               case AUDIT:
6230               case COMPOUND:
6231               case DATABASE:
6232               case CALL:
6233               case DDL:
6234               case DISASSOCIATE:
6235               case EACH:
6236               case FOLLOWS:
6237               case LOGOFF:
6238               case LOGON:
6239               case NESTED:
6240               case NOAUDIT:
6241               case SCHEMA:
6242               case SERVERERROR:
6243               case SHUTDOWN:
6244               case STARTUP:
6245               case STATEMENT:
6246               case STATISTICS:
6247               case SUSPEND:
6248               case TRUNCATE:
6249               case WRAPPED:
6250               case LIBRARY:
6251               case NAME:
6252               case STRUCT:
6253               case CONTEXT:
6254               case PARAMETERS:
6255               case LENGTH:
6256               case TDO:
6257               case MAXLEN:
6258               case CHARSETID:
6259               case CHARSETFORM:
6260               case ACCEPT:
6261               case ACCESSIBLE:
6262               case COPY:
6263               case DEFINE:
6264               case DISCONNECT:
6265               case HOST:
6266               case PRINT:
6267               case QUIT:
6268               case REMARK:
6269               case UNDEFINE:
6270               case VARIABLE:
6271               case WHENEVER:
6272               case ATTACH:
6273               case CAST:
6274               case TREAT:
6275               case TRIM:
6276               case LEFT:
6277               case RIGHT:
6278               case BOTH:
6279               case EMPTY:
6280               case MULTISET:
6281               case SUBMULTISET:
6282               case LEADING:
6283               case TRAILING:
6284               case CHAR_CS:
6285               case NCHAR_CS:
6286               case DBTIMEZONE:
6287               case SESSIONTIMEZONE:
6288               case AUTHENTICATED:
6289               case LINK:
6290               case SHARED:
6291               case DIRECTORY:
6292               case USER:
6293               case IDENTIFIER:
6294               case QUOTED_LITERAL:
6295               case SQLDATA_CLASS:
6296               case CUSTOMDATUM_CLASS:
6297               case ORADATA_CLASS:
6298               case JAVA_INTERFACE_CLASS:
6299                 ID();
6300                 break;
6301               default:
6302                 jj_la1[67] = jj_gen;
6303                 ;
6304               }
6305               break;
6306             default:
6307               jj_la1[68] = jj_gen;
6308               jj_consume_token(-1);
6309               throw new ParseException();
6310             }
6311           }
6312           break;
6313         default:
6314           jj_la1[69] = jj_gen;
6315           ;
6316         }
6317         jj_consume_token(4);
6318         break;
6319       default:
6320         jj_la1[70] = jj_gen;
6321         jj_consume_token(-1);
6322         throw new ParseException();
6323       }
6324         jjtree.closeNodeScope(jjtn000, true);
6325         jjtc000 = false;
6326         {if (true) return jjtn000 ;}
6327     } catch (Throwable jjte000) {
6328           if (jjtc000) {
6329             jjtree.clearNodeScope(jjtn000);
6330             jjtc000 = false;
6331           } else {
6332             jjtree.popNode();
6333           }
6334           if (jjte000 instanceof RuntimeException) {
6335             {if (true) throw (RuntimeException)jjte000;}
6336           }
6337           if (jjte000 instanceof ParseException) {
6338             {if (true) throw (ParseException)jjte000;}
6339           }
6340           {if (true) throw (Error)jjte000;}
6341     } finally {
6342           if (jjtc000) {
6343             jjtree.closeNodeScope(jjtn000, true);
6344           }
6345     }
6346     throw new Error("Missing return statement in function");
6347   }
6348 
6349   final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6350  /*@bgen(jjtree) ObjectNameDeclaration */
6351  ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6352  boolean jjtc000 = true;
6353  jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6354     try {
6355       if (jj_2_22(2)) {
6356         schemaName = ID();
6357         jj_consume_token(3);
6358       } else {
6359         ;
6360       }
6361       objectName = ID();
6362     jjtn000.setImage(  (null == schemaName) ?  objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() )  )  ;
6363     jjtree.closeNodeScope(jjtn000, true);
6364     jjtc000 = false;
6365     {if (true) return jjtn000 ;}
6366     } catch (Throwable jjte000) {
6367     if (jjtc000) {
6368       jjtree.clearNodeScope(jjtn000);
6369       jjtc000 = false;
6370     } else {
6371       jjtree.popNode();
6372     }
6373     if (jjte000 instanceof RuntimeException) {
6374       {if (true) throw (RuntimeException)jjte000;}
6375     }
6376     if (jjte000 instanceof ParseException) {
6377       {if (true) throw (ParseException)jjte000;}
6378     }
6379     {if (true) throw (Error)jjte000;}
6380     } finally {
6381     if (jjtc000) {
6382       jjtree.closeNodeScope(jjtn000, true);
6383     }
6384     }
6385     throw new Error("Missing return statement in function");
6386   }
6387 
6388   final public ASTFormalParameter FormalParameter() throws ParseException {
6389  /*@bgen(jjtree) FormalParameter */
6390  ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6391  boolean jjtc000 = true;
6392  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6393     try {
6394       simpleNode = ID();
6395       if (jj_2_25(2)) {
6396         if (jj_2_24(2)) {
6397           switch (jj_nt.kind) {
6398           case OUT:
6399             jj_consume_token(OUT);
6400             break;
6401           case IN:
6402             jj_consume_token(IN);
6403             jj_consume_token(OUT);
6404             break;
6405           default:
6406             jj_la1[71] = jj_gen;
6407             jj_consume_token(-1);
6408             throw new ParseException();
6409           }
6410           if (jj_2_23(2)) {
6411             jj_consume_token(NOCOPY);
6412           } else {
6413             ;
6414           }
6415         } else {
6416           switch (jj_nt.kind) {
6417           case IN:
6418             jj_consume_token(IN);
6419             break;
6420           default:
6421             jj_la1[72] = jj_gen;
6422             jj_consume_token(-1);
6423             throw new ParseException();
6424           }
6425         }
6426       } else {
6427         ;
6428       }
6429       switch (jj_nt.kind) {
6430       case 8:
6431         jj_consume_token(8);
6432         break;
6433       case REPLACE:
6434       case DEFINER:
6435       case CURRENT_USER:
6436       case LANGUAGE:
6437       case INLINE:
6438       case ADD:
6439       case AGGREGATE:
6440       case ARRAY:
6441       case AT:
6442       case ATTRIBUTE:
6443       case AUTHID:
6444       case BINARY_INTEGER:
6445       case BODY:
6446       case BOOLEAN:
6447       case BULK:
6448       case BYTE:
6449       case CASCADE:
6450       case CHAR:
6451       case CHAR_BASE:
6452       case CLOSE:
6453       case COALESCE:
6454       case COLLECT:
6455       case COLUMN:
6456       case COMMENT:
6457       case COMMIT:
6458       case CONSTRUCTOR:
6459       case CONTINUE:
6460       case CONVERT:
6461       case CURRENT:
6462       case CURSOR:
6463       case DATA:
6464       case DATE:
6465       case DAY:
6466       case DECIMAL:
6467       case DISABLE:
6468       case EDITIONABLE:
6469       case ELEMENT:
6470       case ENABLE:
6471       case ESCAPE:
6472       case EXCEPT:
6473       case EXCEPTIONS:
6474       case EXIT:
6475       case EXTERNAL:
6476       case EXTENDS:
6477       case EXTRACT:
6478       case FALSE:
6479       case FINAL:
6480       case FLOAT:
6481       case FORCE:
6482       case FUNCTION:
6483       case GLOBAL:
6484       case HASH:
6485       case HEAP:
6486       case HOUR:
6487       case IMMEDIATE:
6488       case INDICES:
6489       case INDEXTYPE:
6490       case INDICATOR:
6491       case INSTANTIABLE:
6492       case INTEGER:
6493       case INTERVAL:
6494       case INVALIDATE:
6495       case ISOLATION:
6496       case JAVA:
6497       case LEVEL:
6498       case LIMIT:
6499       case LONG:
6500       case LOOP:
6501       case MAP:
6502       case MAX:
6503       case MEMBER:
6504       case MERGE:
6505       case MIN:
6506       case MINUTE:
6507       case MLSLABEL:
6508       case MODIFY:
6509       case MOD:
6510       case MONTH:
6511       case NATURAL:
6512       case NATURALN:
6513       case NEW:
6514       case NO:
6515       case NONEDITIONABLE:
6516       case NULLIF:
6517       case NUMBER:
6518       case BFILE_BASE:
6519       case BLOB_BASE:
6520       case CLOB_BASE:
6521       case DATE_BASE:
6522       case NUMBER_BASE:
6523       case OBJECT:
6524       case OID:
6525       case OPAQUE:
6526       case OPEN:
6527       case OPERATOR:
6528       case ORGANIZATION:
6529       case OTHERS:
6530       case OVERRIDING:
6531       case PACKAGE:
6532       case PARTITION:
6533       case PLS_INTEGER:
6534       case POSITIVE:
6535       case POSITIVEN:
6536       case PRESERVE:
6537       case PRIVATE:
6538       case PROCEDURE:
6539       case RANGE:
6540       case RAW:
6541       case REAL:
6542       case RECORD:
6543       case REF:
6544       case RELEASE:
6545       case RELIES_ON:
6546       case RENAME:
6547       case RESULT:
6548       case RETURN:
6549       case RETURNING:
6550       case REVERSE:
6551       case ROLLBACK:
6552       case ROW:
6553       case ROWS:
6554       case ROWID:
6555       case ROWNUM:
6556       case SAVE:
6557       case SAVEPOINT:
6558       case SECOND:
6559       case SELF:
6560       case SET:
6561       case SMALLINT:
6562       case SPACE:
6563       case SQL:
6564       case SQLCODE:
6565       case SQLERRM:
6566       case STATIC:
6567       case SUBTYPE:
6568       case SUBSTITUTABLE:
6569       case SUCCESSFUL:
6570       case SYSDATE:
6571       case SYS_REFCURSOR:
6572       case TEMPORARY:
6573       case TIME:
6574       case TIMESTAMP:
6575       case TIMEZONE_REGION:
6576       case TIMEZONE_ABBR:
6577       case TIMEZONE_MINUTE:
6578       case TIMEZONE_HOUR:
6579       case TRANSACTION:
6580       case TRUE:
6581       case TYPE:
6582       case UNDER:
6583       case USING:
6584       case YES:
6585       case SHOW:
6586       case A:
6587       case VARCHAR:
6588       case VARCHAR2:
6589       case DOUBLE:
6590       case DEC:
6591       case PRECISION:
6592       case INT:
6593       case NUMERIC:
6594       case SIGNTYPE:
6595       case NCHAR:
6596       case NVARCHAR2:
6597       case STRING:
6598       case UROWID:
6599       case VARRAY:
6600       case VARYING:
6601       case BFILE:
6602       case BLOB:
6603       case CLOB:
6604       case NCLOB:
6605       case YEAR:
6606       case LOCAL:
6607       case ZONE:
6608       case CHARACTER:
6609       case AFTER:
6610       case BEFORE:
6611       case OLD:
6612       case PARENT:
6613       case CC_IF:
6614       case ANALYZE:
6615       case ASSOCIATE:
6616       case AUDIT:
6617       case COMPOUND:
6618       case DATABASE:
6619       case CALL:
6620       case DDL:
6621       case DISASSOCIATE:
6622       case EACH:
6623       case FOLLOWS:
6624       case LOGOFF:
6625       case LOGON:
6626       case NESTED:
6627       case NOAUDIT:
6628       case SCHEMA:
6629       case SERVERERROR:
6630       case SHUTDOWN:
6631       case STARTUP:
6632       case STATEMENT:
6633       case STATISTICS:
6634       case SUSPEND:
6635       case TRUNCATE:
6636       case WRAPPED:
6637       case LIBRARY:
6638       case NAME:
6639       case STRUCT:
6640       case CONTEXT:
6641       case PARAMETERS:
6642       case LENGTH:
6643       case TDO:
6644       case MAXLEN:
6645       case CHARSETID:
6646       case CHARSETFORM:
6647       case ACCEPT:
6648       case ACCESSIBLE:
6649       case COPY:
6650       case DEFINE:
6651       case DISCONNECT:
6652       case HOST:
6653       case PRINT:
6654       case QUIT:
6655       case REMARK:
6656       case UNDEFINE:
6657       case VARIABLE:
6658       case WHENEVER:
6659       case ATTACH:
6660       case CAST:
6661       case TREAT:
6662       case TRIM:
6663       case LEFT:
6664       case RIGHT:
6665       case BOTH:
6666       case EMPTY:
6667       case MULTISET:
6668       case SUBMULTISET:
6669       case LEADING:
6670       case TRAILING:
6671       case CHAR_CS:
6672       case NCHAR_CS:
6673       case DBTIMEZONE:
6674       case SESSIONTIMEZONE:
6675       case AUTHENTICATED:
6676       case LINK:
6677       case SHARED:
6678       case DIRECTORY:
6679       case USER:
6680       case IDENTIFIER:
6681       case QUOTED_LITERAL:
6682         Datatype();
6683         break;
6684       default:
6685         jj_la1[73] = jj_gen;
6686         jj_consume_token(-1);
6687         throw new ParseException();
6688       }
6689       switch (jj_nt.kind) {
6690       case 9:
6691       case _DEFAULT:
6692         switch (jj_nt.kind) {
6693         case 9:
6694           jj_consume_token(9);
6695           jj_consume_token(10);
6696           break;
6697         case _DEFAULT:
6698           jj_consume_token(_DEFAULT);
6699           break;
6700         default:
6701           jj_la1[74] = jj_gen;
6702           jj_consume_token(-1);
6703           throw new ParseException();
6704         }
6705         Expression();
6706         break;
6707       default:
6708         jj_la1[75] = jj_gen;
6709         ;
6710       }
6711      jjtree.closeNodeScope(jjtn000, true);
6712      jjtc000 = false;
6713      jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6714     } catch (Throwable jjte000) {
6715      if (jjtc000) {
6716        jjtree.clearNodeScope(jjtn000);
6717        jjtc000 = false;
6718      } else {
6719        jjtree.popNode();
6720      }
6721      if (jjte000 instanceof RuntimeException) {
6722        {if (true) throw (RuntimeException)jjte000;}
6723      }
6724      if (jjte000 instanceof ParseException) {
6725        {if (true) throw (ParseException)jjte000;}
6726      }
6727      {if (true) throw (Error)jjte000;}
6728     } finally {
6729      if (jjtc000) {
6730        jjtree.closeNodeScope(jjtn000, true);
6731      }
6732     }
6733     throw new Error("Missing return statement in function");
6734   }
6735 
6736   final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6737  /*@bgen(jjtree) MethodDeclaration */
6738   ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6739   boolean jjtc000 = true;
6740   jjtree.openNodeScope(jjtn000);
6741     try {
6742       switch (jj_nt.kind) {
6743       case CREATE:
6744       case FUNCTION:
6745       case PROCEDURE:
6746         ProgramUnit();
6747         break;
6748       case CONSTRUCTOR:
6749       case FINAL:
6750       case INSTANTIABLE:
6751       case MAP:
6752       case MEMBER:
6753       case NOT:
6754       case ORDER:
6755       case OVERRIDING:
6756       case STATIC:
6757         TypeMethod();
6758         break;
6759       default:
6760         jj_la1[76] = jj_gen;
6761         jj_consume_token(-1);
6762         throw new ParseException();
6763       }
6764     jjtree.closeNodeScope(jjtn000, true);
6765     jjtc000 = false;
6766     {if (true) return jjtn000 ;}
6767     } catch (Throwable jjte000) {
6768     if (jjtc000) {
6769       jjtree.clearNodeScope(jjtn000);
6770       jjtc000 = false;
6771     } else {
6772       jjtree.popNode();
6773     }
6774     if (jjte000 instanceof RuntimeException) {
6775       {if (true) throw (RuntimeException)jjte000;}
6776     }
6777     if (jjte000 instanceof ParseException) {
6778       {if (true) throw (ParseException)jjte000;}
6779     }
6780     {if (true) throw (Error)jjte000;}
6781     } finally {
6782     if (jjtc000) {
6783       jjtree.closeNodeScope(jjtn000, true);
6784     }
6785     }
6786     throw new Error("Missing return statement in function");
6787   }
6788 
6789   final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6790  /*@bgen(jjtree) MethodDeclarator */
6791  ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6792  boolean jjtc000 = true;
6793  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6794     try {
6795       switch (jj_nt.kind) {
6796       case FUNCTION:
6797         jj_consume_token(FUNCTION);
6798         simpleNode = ObjectNameDeclaration();
6799         switch (jj_nt.kind) {
6800         case 5:
6801           FormalParameters();
6802           break;
6803         default:
6804           jj_la1[77] = jj_gen;
6805           ;
6806         }
6807         Token nextToken;
6808         nextToken = getToken(1); //ReadAhead
6809         if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6810             &&
6811             !nextToken.image.equalsIgnoreCase("RETURN")
6812            )
6813         {
6814           {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6815                                               + nextToken.image
6816                                               + "\u005c" at line "+nextToken.beginLine
6817                                               + ", column "+nextToken.beginColumn
6818                                              );}
6819         }
6820         switch (jj_nt.kind) {
6821         case RETURN:
6822           jj_consume_token(RETURN);
6823           Datatype();
6824           break;
6825         default:
6826           jj_la1[78] = jj_gen;
6827           ;
6828         }
6829         break;
6830       case PROCEDURE:
6831         jj_consume_token(PROCEDURE);
6832         simpleNode = ObjectNameDeclaration();
6833         switch (jj_nt.kind) {
6834         case 5:
6835           FormalParameters();
6836           break;
6837         default:
6838           jj_la1[79] = jj_gen;
6839           ;
6840         }
6841         break;
6842       default:
6843         jj_la1[80] = jj_gen;
6844         jj_consume_token(-1);
6845         throw new ParseException();
6846       }
6847     jjtree.closeNodeScope(jjtn000, true);
6848     jjtc000 = false;
6849     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6850     } catch (Throwable jjte000) {
6851     if (jjtc000) {
6852       jjtree.clearNodeScope(jjtn000);
6853       jjtc000 = false;
6854     } else {
6855       jjtree.popNode();
6856     }
6857     if (jjte000 instanceof RuntimeException) {
6858       {if (true) throw (RuntimeException)jjte000;}
6859     }
6860     if (jjte000 instanceof ParseException) {
6861       {if (true) throw (ParseException)jjte000;}
6862     }
6863     {if (true) throw (Error)jjte000;}
6864     } finally {
6865     if (jjtc000) {
6866       jjtree.closeNodeScope(jjtn000, true);
6867     }
6868     }
6869     throw new Error("Missing return statement in function");
6870   }
6871 
6872   final public ASTFormalParameters FormalParameters() throws ParseException {
6873  /*@bgen(jjtree) FormalParameters */
6874  ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6875  boolean jjtc000 = true;
6876  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6877  StringBuilder sb = new StringBuilder();
6878     try {
6879       jj_consume_token(5);
6880         sb.append("(");
6881       switch (jj_nt.kind) {
6882       case REPLACE:
6883       case DEFINER:
6884       case CURRENT_USER:
6885       case SERIALLY_REUSABLE:
6886       case RESTRICT_REFERENCES:
6887       case EXCEPTION_INIT:
6888       case AUTONOMOUS_TRANSACTION:
6889       case LANGUAGE:
6890       case INLINE:
6891       case ADD:
6892       case AGGREGATE:
6893       case ALL:
6894       case ALTER:
6895       case AND:
6896       case ANY:
6897       case ARRAY:
6898       case AS:
6899       case ASC:
6900       case AT:
6901       case ATTRIBUTE:
6902       case AUTHID:
6903       case AVG:
6904       case BETWEEN:
6905       case BINARY_INTEGER:
6906       case BODY:
6907       case BOOLEAN:
6908       case BULK:
6909       case BY:
6910       case BYTE:
6911       case CASCADE:
6912       case CASE:
6913       case CHAR:
6914       case CHAR_BASE:
6915       case CHECK:
6916       case CLOSE:
6917       case CLUSTER:
6918       case COALESCE:
6919       case COLLECT:
6920       case COLUMN:
6921       case COMMENT:
6922       case COMMIT:
6923       case COMPRESS:
6924       case CONNECT:
6925       case CONSTANT:
6926       case CONSTRUCTOR:
6927       case CONTINUE:
6928       case CONVERT:
6929       case CREATE:
6930       case CURRENT:
6931       case CURRVAL:
6932       case CURSOR:
6933       case DATA:
6934       case DATE:
6935       case DAY:
6936       case DECLARE:
6937       case DECIMAL:
6938       case _DEFAULT:
6939       case DELETE:
6940       case DESC:
6941       case DISABLE:
6942       case DISTINCT:
6943       case DO:
6944       case DROP:
6945       case EDITIONABLE:
6946       case ELEMENT:
6947       case ELSE:
6948       case ELSIF:
6949       case ENABLE:
6950       case ESCAPE:
6951       case EXCEPT:
6952       case EXCEPTION:
6953       case EXCEPTIONS:
6954       case EXCLUSIVE:
6955       case EXECUTE:
6956       case EXISTS:
6957       case EXIT:
6958       case EXTERNAL:
6959       case EXTENDS:
6960       case EXTRACT:
6961       case FALSE:
6962       case FETCH:
6963       case FINAL:
6964       case FLOAT:
6965       case FOR:
6966       case FORALL:
6967       case FORCE:
6968       case FROM:
6969       case FUNCTION:
6970       case GLOBAL:
6971       case GOTO:
6972       case GROUP:
6973       case HASH:
6974       case HAVING:
6975       case HEAP:
6976       case HOUR:
6977       case IF:
6978       case IMMEDIATE:
6979       case IN:
6980       case INDEX:
6981       case INDICES:
6982       case INDEXTYPE:
6983       case INDICATOR:
6984       case INSERT:
6985       case INSTANTIABLE:
6986       case INTEGER:
6987       case INTERFACE:
6988       case INTERSECT:
6989       case INTERVAL:
6990       case INTO:
6991       case INVALIDATE:
6992       case IS:
6993       case ISOLATION:
6994       case JAVA:
6995       case LEVEL:
6996       case LIKE:
6997       case LIMIT:
6998       case LIMITED:
6999       case LOCK:
7000       case LONG:
7001       case LOOP:
7002       case MAP:
7003       case MAX:
7004       case MEMBER:
7005       case MERGE:
7006       case MIN:
7007       case MINUS:
7008       case MINUTE:
7009       case MLSLABEL:
7010       case MODIFY:
7011       case MOD:
7012       case MODE:
7013       case MONTH:
7014       case NATURAL:
7015       case NATURALN:
7016       case NEW:
7017       case NEXTVAL:
7018       case NO:
7019       case NOCOPY:
7020       case NONEDITIONABLE:
7021       case NOT:
7022       case NOWAIT:
7023       case NULL:
7024       case NULLIF:
7025       case NUMBER:
7026       case BFILE_BASE:
7027       case BLOB_BASE:
7028       case CLOB_BASE:
7029       case DATE_BASE:
7030       case NUMBER_BASE:
7031       case OBJECT:
7032       case OCIROWID:
7033       case OF:
7034       case OID:
7035       case ON:
7036       case OPAQUE:
7037       case OPEN:
7038       case OPERATOR:
7039       case OPTION:
7040       case OR:
7041       case ORDER:
7042       case ORGANIZATION:
7043       case OTHERS:
7044       case OUT:
7045       case OVERRIDING:
7046       case PACKAGE:
7047       case PARTITION:
7048       case PCTFREE:
7049       case PLS_INTEGER:
7050       case POSITIVE:
7051       case POSITIVEN:
7052       case PRESERVE:
7053       case PRIOR:
7054       case PROMPT:
7055       case PRIVATE:
7056       case PROCEDURE:
7057       case PUBLIC:
7058       case RAISE:
7059       case RANGE:
7060       case RAW:
7061       case REAL:
7062       case RECORD:
7063       case REF:
7064       case RELEASE:
7065       case RELIES_ON:
7066       case RENAME:
7067       case RESULT:
7068       case RETURN:
7069       case RETURNING:
7070       case REVERSE:
7071       case ROLLBACK:
7072       case ROW:
7073       case ROWS:
7074       case ROWID:
7075       case ROWNUM:
7076       case ROWTYPE:
7077       case SAVE:
7078       case SAVEPOINT:
7079       case SECOND:
7080       case SELECT:
7081       case SELF:
7082       case SEPARATE:
7083       case SET:
7084       case SHARE:
7085       case SMALLINT:
7086       case SPACE:
7087       case SQL:
7088       case SQLCODE:
7089       case SQLERRM:
7090       case START:
7091       case STATIC:
7092       case STDDEV:
7093       case SUBTYPE:
7094       case SUBSTITUTABLE:
7095       case SUCCESSFUL:
7096       case SUM:
7097       case SYNONYM:
7098       case SYSDATE:
7099       case SYS_REFCURSOR:
7100       case TABLE:
7101       case TEMPORARY:
7102       case THEN:
7103       case TIME:
7104       case TIMESTAMP:
7105       case TIMEZONE_REGION:
7106       case TIMEZONE_ABBR:
7107       case TIMEZONE_MINUTE:
7108       case TIMEZONE_HOUR:
7109       case TO:
7110       case TRANSACTION:
7111       case TRIGGER:
7112       case TRUE:
7113       case TYPE:
7114       case UI:
7115       case UNDER:
7116       case USING:
7117       case WHILE:
7118       case YES:
7119       case SHOW:
7120       case A:
7121       case UPDATE:
7122       case VARCHAR:
7123       case VARCHAR2:
7124       case DOUBLE:
7125       case DEC:
7126       case PRECISION:
7127       case INT:
7128       case NUMERIC:
7129       case SIGNTYPE:
7130       case NCHAR:
7131       case NVARCHAR2:
7132       case STRING:
7133       case UROWID:
7134       case VARRAY:
7135       case VARYING:
7136       case BFILE:
7137       case BLOB:
7138       case CLOB:
7139       case NCLOB:
7140       case YEAR:
7141       case LOCAL:
7142       case WITH:
7143       case ZONE:
7144       case CHARACTER:
7145       case AFTER:
7146       case BEFORE:
7147       case OLD:
7148       case PARENT:
7149       case ANALYZE:
7150       case ASSOCIATE:
7151       case AUDIT:
7152       case COMPOUND:
7153       case DATABASE:
7154       case CALL:
7155       case DDL:
7156       case DISASSOCIATE:
7157       case EACH:
7158       case FOLLOWS:
7159       case LOGOFF:
7160       case LOGON:
7161       case NESTED:
7162       case NOAUDIT:
7163       case SCHEMA:
7164       case SERVERERROR:
7165       case SHUTDOWN:
7166       case STARTUP:
7167       case STATEMENT:
7168       case STATISTICS:
7169       case SUSPEND:
7170       case TRUNCATE:
7171       case WRAPPED:
7172       case LIBRARY:
7173       case NAME:
7174       case STRUCT:
7175       case CONTEXT:
7176       case PARAMETERS:
7177       case LENGTH:
7178       case TDO:
7179       case MAXLEN:
7180       case CHARSETID:
7181       case CHARSETFORM:
7182       case ACCEPT:
7183       case ACCESSIBLE:
7184       case COPY:
7185       case DEFINE:
7186       case DISCONNECT:
7187       case HOST:
7188       case PRINT:
7189       case QUIT:
7190       case REMARK:
7191       case UNDEFINE:
7192       case VARIABLE:
7193       case WHENEVER:
7194       case ATTACH:
7195       case CAST:
7196       case TREAT:
7197       case TRIM:
7198       case LEFT:
7199       case RIGHT:
7200       case BOTH:
7201       case EMPTY:
7202       case MULTISET:
7203       case SUBMULTISET:
7204       case LEADING:
7205       case TRAILING:
7206       case CHAR_CS:
7207       case NCHAR_CS:
7208       case DBTIMEZONE:
7209       case SESSIONTIMEZONE:
7210       case AUTHENTICATED:
7211       case LINK:
7212       case SHARED:
7213       case DIRECTORY:
7214       case USER:
7215       case IDENTIFIER:
7216       case QUOTED_LITERAL:
7217       case SQLDATA_CLASS:
7218       case CUSTOMDATUM_CLASS:
7219       case ORADATA_CLASS:
7220       case JAVA_INTERFACE_CLASS:
7221         simpleNode = FormalParameter();
7222                                          sb.append(simpleNode.getImage());
7223         label_17:
7224         while (true) {
7225           switch (jj_nt.kind) {
7226           case 6:
7227             ;
7228             break;
7229           default:
7230             jj_la1[81] = jj_gen;
7231             break label_17;
7232           }
7233           jj_consume_token(6);
7234           simpleNode = FormalParameter();
7235                                                sb.append(","+simpleNode.getImage());
7236         }
7237         break;
7238       default:
7239         jj_la1[82] = jj_gen;
7240         ;
7241       }
7242       jj_consume_token(7);
7243        sb.append(")");
7244     jjtree.closeNodeScope(jjtn000, true);
7245     jjtc000 = false;
7246     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7247     } catch (Throwable jjte000) {
7248     if (jjtc000) {
7249       jjtree.clearNodeScope(jjtn000);
7250       jjtc000 = false;
7251     } else {
7252       jjtree.popNode();
7253     }
7254     if (jjte000 instanceof RuntimeException) {
7255       {if (true) throw (RuntimeException)jjte000;}
7256     }
7257     if (jjte000 instanceof ParseException) {
7258       {if (true) throw (ParseException)jjte000;}
7259     }
7260     {if (true) throw (Error)jjte000;}
7261     } finally {
7262     if (jjtc000) {
7263       jjtree.closeNodeScope(jjtn000, true);
7264     }
7265     }
7266     throw new Error("Missing return statement in function");
7267   }
7268 
7269   final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7270  /*@bgen(jjtree) VariableOrConstantDeclarator */
7271  ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7272  boolean jjtc000 = true;
7273  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7274  StringBuilder sb = new StringBuilder();
7275     try {
7276       simpleNode = VariableOrConstantDeclaratorId();
7277                                                   sb.append(simpleNode.getImage());
7278       if (jj_2_26(2)) {
7279         jj_consume_token(CONSTANT);
7280                             sb.append(" " + token.image);
7281       } else {
7282         ;
7283       }
7284       simpleNode = Datatype();
7285                                                                                        sb.append(" " + simpleNode.getImage());
7286       switch (jj_nt.kind) {
7287       case NOT:
7288       case NULL:
7289         switch (jj_nt.kind) {
7290         case NOT:
7291           jj_consume_token(NOT);
7292            sb.append(" " + token.image);
7293           break;
7294         default:
7295           jj_la1[83] = jj_gen;
7296           ;
7297         }
7298         jj_consume_token(NULL);
7299                                                     sb.append(" " + token.image);
7300         break;
7301       default:
7302         jj_la1[84] = jj_gen;
7303         ;
7304       }
7305       switch (jj_nt.kind) {
7306       case 9:
7307       case _DEFAULT:
7308         switch (jj_nt.kind) {
7309         case 9:
7310           jj_consume_token(9);
7311           jj_consume_token(10);
7312                sb.append(" :=");
7313           break;
7314         case _DEFAULT:
7315           jj_consume_token(_DEFAULT);
7316                                                sb.append(" " + token.image);
7317           break;
7318         default:
7319           jj_la1[85] = jj_gen;
7320           jj_consume_token(-1);
7321           throw new ParseException();
7322         }
7323         simpleNode = VariableOrConstantInitializer();
7324                                                    sb.append(" " + simpleNode.getImage());
7325         break;
7326       default:
7327         jj_la1[86] = jj_gen;
7328         ;
7329       }
7330     jjtree.closeNodeScope(jjtn000, true);
7331     jjtc000 = false;
7332     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7333     } catch (Throwable jjte000) {
7334     if (jjtc000) {
7335       jjtree.clearNodeScope(jjtn000);
7336       jjtc000 = false;
7337     } else {
7338       jjtree.popNode();
7339     }
7340     if (jjte000 instanceof RuntimeException) {
7341       {if (true) throw (RuntimeException)jjte000;}
7342     }
7343     if (jjte000 instanceof ParseException) {
7344       {if (true) throw (ParseException)jjte000;}
7345     }
7346     {if (true) throw (Error)jjte000;}
7347     } finally {
7348     if (jjtc000) {
7349       jjtree.closeNodeScope(jjtn000, true);
7350     }
7351     }
7352     throw new Error("Missing return statement in function");
7353   }
7354 
7355   final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7356  /*@bgen(jjtree) VariableOrConstantDeclaratorId */
7357  ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7358  boolean jjtc000 = true;
7359  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7360     try {
7361       simpleNode = ID();
7362     jjtree.closeNodeScope(jjtn000, true);
7363     jjtc000 = false;
7364     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7365     } catch (Throwable jjte000) {
7366     if (jjtc000) {
7367       jjtree.clearNodeScope(jjtn000);
7368       jjtc000 = false;
7369     } else {
7370       jjtree.popNode();
7371     }
7372     if (jjte000 instanceof RuntimeException) {
7373       {if (true) throw (RuntimeException)jjte000;}
7374     }
7375     if (jjte000 instanceof ParseException) {
7376       {if (true) throw (ParseException)jjte000;}
7377     }
7378     {if (true) throw (Error)jjte000;}
7379     } finally {
7380     if (jjtc000) {
7381       jjtree.closeNodeScope(jjtn000, true);
7382     }
7383     }
7384     throw new Error("Missing return statement in function");
7385   }
7386 
7387   final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7388  /*@bgen(jjtree) VariableOrConstantInitializer */
7389  ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7390  boolean jjtc000 = true;
7391  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7392     try {
7393       simpleNode = Expression();
7394     jjtree.closeNodeScope(jjtn000, true);
7395     jjtc000 = false;
7396     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7397     } catch (Throwable jjte000) {
7398    if (jjtc000) {
7399      jjtree.clearNodeScope(jjtn000);
7400      jjtc000 = false;
7401    } else {
7402      jjtree.popNode();
7403    }
7404    if (jjte000 instanceof RuntimeException) {
7405      {if (true) throw (RuntimeException)jjte000;}
7406    }
7407    if (jjte000 instanceof ParseException) {
7408      {if (true) throw (ParseException)jjte000;}
7409    }
7410    {if (true) throw (Error)jjte000;}
7411     } finally {
7412    if (jjtc000) {
7413      jjtree.closeNodeScope(jjtn000, true);
7414    }
7415     }
7416     throw new Error("Missing return statement in function");
7417   }
7418 
7419   final public ASTDatatype Datatype() throws ParseException {
7420  /*@bgen(jjtree) Datatype */
7421  ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7422  boolean jjtc000 = true;
7423  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7424  StringBuilder sb = new StringBuilder();
7425     try {
7426       switch (jj_nt.kind) {
7427       case CC_IF:
7428         // this should be first
7429                         simpleNode = CompilationDataType();
7430                                                     sb.append(simpleNode.getImage());
7431         break;
7432       default:
7433         jj_la1[90] = jj_gen;
7434         if (jj_2_28(2)) {
7435           simpleNode = ScalarDataTypeName();
7436                                                                 sb.append(simpleNode.getImage());
7437         } else {
7438           switch (jj_nt.kind) {
7439           case REPLACE:
7440           case DEFINER:
7441           case CURRENT_USER:
7442           case LANGUAGE:
7443           case INLINE:
7444           case ADD:
7445           case AGGREGATE:
7446           case ARRAY:
7447           case AT:
7448           case ATTRIBUTE:
7449           case AUTHID:
7450           case BODY:
7451           case BULK:
7452           case BYTE:
7453           case CASCADE:
7454           case CLOSE:
7455           case COALESCE:
7456           case COLLECT:
7457           case COLUMN:
7458           case COMMENT:
7459           case COMMIT:
7460           case CONSTRUCTOR:
7461           case CONTINUE:
7462           case CONVERT:
7463           case CURRENT:
7464           case CURSOR:
7465           case DATA:
7466           case DAY:
7467           case DISABLE:
7468           case EDITIONABLE:
7469           case ELEMENT:
7470           case ENABLE:
7471           case ESCAPE:
7472           case EXCEPT:
7473           case EXCEPTIONS:
7474           case EXIT:
7475           case EXTERNAL:
7476           case EXTENDS:
7477           case EXTRACT:
7478           case FALSE:
7479           case FINAL:
7480           case FORCE:
7481           case FUNCTION:
7482           case GLOBAL:
7483           case HASH:
7484           case HEAP:
7485           case HOUR:
7486           case IMMEDIATE:
7487           case INDICES:
7488           case INDEXTYPE:
7489           case INDICATOR:
7490           case INSTANTIABLE:
7491           case INTERVAL:
7492           case INVALIDATE:
7493           case ISOLATION:
7494           case JAVA:
7495           case LEVEL:
7496           case LIMIT:
7497           case LOOP:
7498           case MAP:
7499           case MAX:
7500           case MEMBER:
7501           case MERGE:
7502           case MIN:
7503           case MINUTE:
7504           case MLSLABEL:
7505           case MODIFY:
7506           case MOD:
7507           case MONTH:
7508           case NATURAL:
7509           case NEW:
7510           case NO:
7511           case NONEDITIONABLE:
7512           case NULLIF:
7513           case OBJECT:
7514           case OID:
7515           case OPAQUE:
7516           case OPEN:
7517           case OPERATOR:
7518           case ORGANIZATION:
7519           case OTHERS:
7520           case OVERRIDING:
7521           case PACKAGE:
7522           case PARTITION:
7523           case PRESERVE:
7524           case PRIVATE:
7525           case PROCEDURE:
7526           case RANGE:
7527           case RAW:
7528           case REAL:
7529           case RECORD:
7530           case REF:
7531           case RELEASE:
7532           case RELIES_ON:
7533           case RENAME:
7534           case RESULT:
7535           case RETURN:
7536           case RETURNING:
7537           case REVERSE:
7538           case ROLLBACK:
7539           case ROW:
7540           case ROWS:
7541           case ROWID:
7542           case ROWNUM:
7543           case SAVE:
7544           case SAVEPOINT:
7545           case SECOND:
7546           case SELF:
7547           case SET:
7548           case SPACE:
7549           case SQL:
7550           case SQLCODE:
7551           case SQLERRM:
7552           case STATIC:
7553           case SUBTYPE:
7554           case SUBSTITUTABLE:
7555           case SUCCESSFUL:
7556           case SYSDATE:
7557           case SYS_REFCURSOR:
7558           case TEMPORARY:
7559           case TIME:
7560           case TIMESTAMP:
7561           case TIMEZONE_REGION:
7562           case TIMEZONE_ABBR:
7563           case TIMEZONE_MINUTE:
7564           case TIMEZONE_HOUR:
7565           case TRANSACTION:
7566           case TRUE:
7567           case TYPE:
7568           case UNDER:
7569           case USING:
7570           case YES:
7571           case SHOW:
7572           case A:
7573           case DOUBLE:
7574           case DEC:
7575           case PRECISION:
7576           case INT:
7577           case NUMERIC:
7578           case NCHAR:
7579           case NVARCHAR2:
7580           case STRING:
7581           case UROWID:
7582           case VARRAY:
7583           case VARYING:
7584           case BFILE:
7585           case BLOB:
7586           case CLOB:
7587           case NCLOB:
7588           case YEAR:
7589           case LOCAL:
7590           case ZONE:
7591           case CHARACTER:
7592           case AFTER:
7593           case BEFORE:
7594           case OLD:
7595           case PARENT:
7596           case ANALYZE:
7597           case ASSOCIATE:
7598           case AUDIT:
7599           case COMPOUND:
7600           case DATABASE:
7601           case CALL:
7602           case DDL:
7603           case DISASSOCIATE:
7604           case EACH:
7605           case FOLLOWS:
7606           case LOGOFF:
7607           case LOGON:
7608           case NESTED:
7609           case NOAUDIT:
7610           case SCHEMA:
7611           case SERVERERROR:
7612           case SHUTDOWN:
7613           case STARTUP:
7614           case STATEMENT:
7615           case STATISTICS:
7616           case SUSPEND:
7617           case TRUNCATE:
7618           case WRAPPED:
7619           case LIBRARY:
7620           case NAME:
7621           case STRUCT:
7622           case CONTEXT:
7623           case PARAMETERS:
7624           case LENGTH:
7625           case TDO:
7626           case MAXLEN:
7627           case CHARSETID:
7628           case CHARSETFORM:
7629           case ACCEPT:
7630           case ACCESSIBLE:
7631           case COPY:
7632           case DEFINE:
7633           case DISCONNECT:
7634           case HOST:
7635           case PRINT:
7636           case QUIT:
7637           case REMARK:
7638           case UNDEFINE:
7639           case VARIABLE:
7640           case WHENEVER:
7641           case ATTACH:
7642           case CAST:
7643           case TREAT:
7644           case TRIM:
7645           case LEFT:
7646           case RIGHT:
7647           case BOTH:
7648           case EMPTY:
7649           case MULTISET:
7650           case SUBMULTISET:
7651           case LEADING:
7652           case TRAILING:
7653           case CHAR_CS:
7654           case NCHAR_CS:
7655           case DBTIMEZONE:
7656           case SESSIONTIMEZONE:
7657           case AUTHENTICATED:
7658           case LINK:
7659           case SHARED:
7660           case DIRECTORY:
7661           case USER:
7662           case IDENTIFIER:
7663           case QUOTED_LITERAL:
7664             if (jj_2_27(2)) {
7665               jj_consume_token(REF);
7666                                           sb.append(token.image);
7667             } else {
7668               ;
7669             }
7670             simpleNode = QualifiedName();
7671                                                                                                     sb.append(simpleNode.getImage());
7672             switch (jj_nt.kind) {
7673             case 2:
7674               jj_consume_token(2);
7675               simpleNode = QualifiedName();
7676                                                        sb.append("@"+simpleNode.getImage());
7677               break;
7678             default:
7679               jj_la1[87] = jj_gen;
7680               ;
7681             }
7682             switch (jj_nt.kind) {
7683             case 11:
7684               jj_consume_token(11);
7685               switch (jj_nt.kind) {
7686               case TYPE:
7687                 jj_consume_token(TYPE);
7688                 break;
7689               case ROWTYPE:
7690                 jj_consume_token(ROWTYPE);
7691                 break;
7692               default:
7693                 jj_la1[88] = jj_gen;
7694                 jj_consume_token(-1);
7695                 throw new ParseException();
7696               }
7697                                             sb.append("%"+token.image);
7698               break;
7699             default:
7700               jj_la1[89] = jj_gen;
7701               ;
7702             }
7703             break;
7704           default:
7705             jj_la1[91] = jj_gen;
7706             jj_consume_token(-1);
7707             throw new ParseException();
7708           }
7709         }
7710       }
7711           jjtree.closeNodeScope(jjtn000, true);
7712           jjtc000 = false;
7713           jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7714     } catch (Throwable jjte000) {
7715           if (jjtc000) {
7716             jjtree.clearNodeScope(jjtn000);
7717             jjtc000 = false;
7718           } else {
7719             jjtree.popNode();
7720           }
7721           if (jjte000 instanceof RuntimeException) {
7722             {if (true) throw (RuntimeException)jjte000;}
7723           }
7724           if (jjte000 instanceof ParseException) {
7725             {if (true) throw (ParseException)jjte000;}
7726           }
7727           {if (true) throw (Error)jjte000;}
7728     } finally {
7729           if (jjtc000) {
7730             jjtree.closeNodeScope(jjtn000, true);
7731           }
7732     }
7733     throw new Error("Missing return statement in function");
7734   }
7735 
7736   final public ASTCompilationDataType CompilationDataType() throws ParseException {
7737  /*@bgen(jjtree) CompilationDataType */
7738   ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7739   boolean jjtc000 = true;
7740   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7741   StringBuilder sb = new StringBuilder() ;
7742     try {
7743       jj_consume_token(CC_IF);
7744                    sb.append(" "); sb.append(token.image) ;
7745       simpleNode = ConditionalOrExpression();
7746                                                  sb.append(" "); sb.append(simpleNode.getImage());
7747       jj_consume_token(CC_THEN);
7748                      sb.append(" "); sb.append(token.image);
7749       simpleNode = Datatype();
7750                                    sb.append(" "); sb.append(simpleNode.getImage());
7751       label_18:
7752       while (true) {
7753         switch (jj_nt.kind) {
7754         case CC_ELSIF:
7755           ;
7756           break;
7757         default:
7758           jj_la1[92] = jj_gen;
7759           break label_18;
7760         }
7761         jj_consume_token(CC_ELSIF);
7762                         sb.append(" "); sb.append(token.image);
7763         simpleNode = ConditionalOrExpression();
7764                                                     sb.append(" "); sb.append(simpleNode.getImage());
7765         jj_consume_token(CC_THEN);
7766                        sb.append(" "); sb.append(token.image);
7767         simpleNode = Datatype();
7768                                      sb.append(" "); sb.append(simpleNode.getImage());
7769       }
7770       label_19:
7771       while (true) {
7772         switch (jj_nt.kind) {
7773         case CC_ELSE:
7774           ;
7775           break;
7776         default:
7777           jj_la1[93] = jj_gen;
7778           break label_19;
7779         }
7780         jj_consume_token(CC_ELSE);
7781                        sb.append(" "); sb.append(token.image);
7782         simpleNode = Datatype();
7783                                       sb.append(" "); sb.append(simpleNode.getImage());
7784       }
7785       jj_consume_token(CC_END);
7786                     sb.append(" "); sb.append(token.image);
7787    jjtree.closeNodeScope(jjtn000, true);
7788    jjtc000 = false;
7789  jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7790     } catch (Throwable jjte000) {
7791           if (jjtc000) {
7792             jjtree.clearNodeScope(jjtn000);
7793             jjtc000 = false;
7794           } else {
7795             jjtree.popNode();
7796           }
7797           if (jjte000 instanceof RuntimeException) {
7798             {if (true) throw (RuntimeException)jjte000;}
7799           }
7800           if (jjte000 instanceof ParseException) {
7801             {if (true) throw (ParseException)jjte000;}
7802           }
7803           {if (true) throw (Error)jjte000;}
7804     } finally {
7805           if (jjtc000) {
7806             jjtree.closeNodeScope(jjtn000, true);
7807           }
7808     }
7809     throw new Error("Missing return statement in function");
7810   }
7811 
7812   final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7813  /*@bgen(jjtree) CollectionTypeName */
7814   ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7815   boolean jjtc000 = true;
7816   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7817         StringBuilder sb = new StringBuilder();
7818     try {
7819       switch (jj_nt.kind) {
7820       case TABLE:
7821         jj_consume_token(TABLE);
7822         break;
7823       case VARRAY:
7824         jj_consume_token(VARRAY);
7825         break;
7826       case VARYING:
7827         jj_consume_token(VARYING);
7828         jj_consume_token(ARRAY);
7829                                                 sb.append( "VARYING ARRAY") ;
7830         break;
7831       default:
7832         jj_la1[94] = jj_gen;
7833         jj_consume_token(-1);
7834         throw new ParseException();
7835       }
7836       if (sb.length() ==  0) {
7837         sb.append(token.toString());
7838       }
7839       if (jj_2_29(2)) {
7840         jj_consume_token(5);
7841         size = NumericLiteral();
7842                                                  sb.append( "(" + size);
7843         switch (jj_nt.kind) {
7844         case 6:
7845           jj_consume_token(6);
7846           precision = NumericLiteral();
7847                                                  sb.append( "," + precision);
7848           break;
7849         default:
7850           jj_la1[95] = jj_gen;
7851           ;
7852         }
7853         switch (jj_nt.kind) {
7854         case CHAR:
7855           jj_consume_token(CHAR);
7856                           sb.append( " CHAR") ;
7857           break;
7858         default:
7859           jj_la1[96] = jj_gen;
7860           ;
7861         }
7862         switch (jj_nt.kind) {
7863         case BYTE:
7864           jj_consume_token(BYTE);
7865                           sb.append( " BYTE") ;
7866           break;
7867         default:
7868           jj_la1[97] = jj_gen;
7869           ;
7870         }
7871         jj_consume_token(7);
7872              sb.append( ")");
7873       } else {
7874         ;
7875       }
7876         jjtree.closeNodeScope(jjtn000, true);
7877         jjtc000 = false;
7878         jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7879     } catch (Throwable jjte000) {
7880        if (jjtc000) {
7881          jjtree.clearNodeScope(jjtn000);
7882          jjtc000 = false;
7883        } else {
7884          jjtree.popNode();
7885        }
7886        if (jjte000 instanceof RuntimeException) {
7887          {if (true) throw (RuntimeException)jjte000;}
7888        }
7889        if (jjte000 instanceof ParseException) {
7890          {if (true) throw (ParseException)jjte000;}
7891        }
7892        {if (true) throw (Error)jjte000;}
7893     } finally {
7894        if (jjtc000) {
7895          jjtree.closeNodeScope(jjtn000, true);
7896        }
7897     }
7898     throw new Error("Missing return statement in function");
7899   }
7900 
7901   final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7902  /*@bgen(jjtree) ScalarDataTypeName */
7903   ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7904   boolean jjtc000 = true;
7905   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7906         StringBuilder name = new StringBuilder();
7907         PLSQLNode characterSet = null;
7908     try {
7909       switch (jj_nt.kind) {
7910       case BFILE_BASE:
7911         jj_consume_token(BFILE_BASE);
7912         break;
7913       case BLOB_BASE:
7914         jj_consume_token(BLOB_BASE);
7915         break;
7916       case CHAR_BASE:
7917         jj_consume_token(CHAR_BASE);
7918         break;
7919       case CLOB_BASE:
7920         jj_consume_token(CLOB_BASE);
7921         break;
7922       case DATE_BASE:
7923         jj_consume_token(DATE_BASE);
7924         break;
7925       case NUMBER_BASE:
7926         jj_consume_token(NUMBER_BASE);
7927         break;
7928       case BINARY_INTEGER:
7929         jj_consume_token(BINARY_INTEGER);
7930         break;
7931       case DEC:
7932         jj_consume_token(DEC);
7933         break;
7934       case DECIMAL:
7935         jj_consume_token(DECIMAL);
7936         break;
7937       case DOUBLE:
7938         jj_consume_token(DOUBLE);
7939         jj_consume_token(PRECISION);
7940                                                                      name.append("DOUBLE PRECISION");
7941         break;
7942       case FLOAT:
7943         jj_consume_token(FLOAT);
7944         break;
7945       case INT:
7946         jj_consume_token(INT);
7947         break;
7948       case INTEGER:
7949         jj_consume_token(INTEGER);
7950         break;
7951       case NATURAL:
7952         jj_consume_token(NATURAL);
7953         break;
7954       case NATURALN:
7955         jj_consume_token(NATURALN);
7956         break;
7957       case NUMBER:
7958         jj_consume_token(NUMBER);
7959         break;
7960       case NUMERIC:
7961         jj_consume_token(NUMERIC);
7962         break;
7963       case PLS_INTEGER:
7964         jj_consume_token(PLS_INTEGER);
7965         break;
7966       case POSITIVE:
7967         jj_consume_token(POSITIVE);
7968         break;
7969       case POSITIVEN:
7970         jj_consume_token(POSITIVEN);
7971         break;
7972       case REAL:
7973         jj_consume_token(REAL);
7974         break;
7975       case SIGNTYPE:
7976         jj_consume_token(SIGNTYPE);
7977         break;
7978       case SMALLINT:
7979         jj_consume_token(SMALLINT);
7980         break;
7981       case CHAR:
7982       case LONG:
7983       case RAW:
7984       case ROWID:
7985       case VARCHAR:
7986       case VARCHAR2:
7987       case NCHAR:
7988       case NVARCHAR2:
7989       case STRING:
7990       case UROWID:
7991       case CLOB:
7992       case NCLOB:
7993       case CHARACTER:
7994         switch (jj_nt.kind) {
7995         case CHAR:
7996           jj_consume_token(CHAR);
7997           break;
7998         case CHARACTER:
7999           jj_consume_token(CHARACTER);
8000           break;
8001         default:
8002           jj_la1[98] = jj_gen;
8003           if (jj_2_30(2)) {
8004             jj_consume_token(LONG);
8005             jj_consume_token(RAW);
8006                                        name.append("LONG RAW");
8007           } else {
8008             switch (jj_nt.kind) {
8009             case LONG:
8010               jj_consume_token(LONG);
8011               break;
8012             case NCHAR:
8013               jj_consume_token(NCHAR);
8014               break;
8015             case NVARCHAR2:
8016               jj_consume_token(NVARCHAR2);
8017               break;
8018             case RAW:
8019               jj_consume_token(RAW);
8020               break;
8021             case ROWID:
8022               jj_consume_token(ROWID);
8023               break;
8024             case STRING:
8025               jj_consume_token(STRING);
8026               break;
8027             case UROWID:
8028               jj_consume_token(UROWID);
8029               break;
8030             case VARCHAR:
8031               jj_consume_token(VARCHAR);
8032               break;
8033             case VARCHAR2:
8034               jj_consume_token(VARCHAR2);
8035               break;
8036             case CLOB:
8037               jj_consume_token(CLOB);
8038               break;
8039             case NCLOB:
8040               jj_consume_token(NCLOB);
8041               break;
8042             default:
8043               jj_la1[99] = jj_gen;
8044               jj_consume_token(-1);
8045               throw new ParseException();
8046             }
8047           }
8048         }
8049         break;
8050       case BOOLEAN:
8051         jj_consume_token(BOOLEAN);
8052         break;
8053       case BFILE:
8054         jj_consume_token(BFILE);
8055         break;
8056       case BLOB:
8057         jj_consume_token(BLOB);
8058         break;
8059       case SYS_REFCURSOR:
8060         jj_consume_token(SYS_REFCURSOR);
8061         break;
8062       case REF:
8063         jj_consume_token(REF);
8064         jj_consume_token(CURSOR);
8065                         name.append("REF CURSOR");
8066         break;
8067       case DATE:
8068         jj_consume_token(DATE);
8069         break;
8070       default:
8071         jj_la1[100] = jj_gen;
8072         if (jj_2_31(2)) {
8073           jj_consume_token(INTERVAL);
8074           jj_consume_token(YEAR);
8075                                         name.append("INTERVAL YEAR");
8076         } else if (jj_2_32(2)) {
8077           jj_consume_token(INTERVAL);
8078           jj_consume_token(DAY);
8079                                        name.append("INTERVAL DAY");
8080         } else {
8081           switch (jj_nt.kind) {
8082           case TIME:
8083             jj_consume_token(TIME);
8084             break;
8085           case TIMESTAMP:
8086             jj_consume_token(TIMESTAMP);
8087             break;
8088           case SELF:
8089             jj_consume_token(SELF);
8090             jj_consume_token(AS);
8091             jj_consume_token(RESULT);
8092                              name.append("SELF AS RESULT");
8093             break;
8094           default:
8095             jj_la1[101] = jj_gen;
8096             jj_consume_token(-1);
8097             throw new ParseException();
8098           }
8099         }
8100       }
8101       if (name.length() == 0 ) {
8102         name.append(token.toString());
8103       }
8104       if (jj_2_33(2)) {
8105         jj_consume_token(5);
8106         size = NumericLiteral();
8107                                                  name.append("("); name.append(size.getImage()) ;
8108         switch (jj_nt.kind) {
8109         case 6:
8110           jj_consume_token(6);
8111           precision = UnaryExpression(true);
8112                                                       name.append(",") ; name.append(precision.getImage()) ;
8113           break;
8114         default:
8115           jj_la1[102] = jj_gen;
8116           ;
8117         }
8118         switch (jj_nt.kind) {
8119         case CHAR:
8120           jj_consume_token(CHAR);
8121                           name.append(" CHAR") ;
8122           break;
8123         default:
8124           jj_la1[103] = jj_gen;
8125           ;
8126         }
8127         switch (jj_nt.kind) {
8128         case BYTE:
8129           jj_consume_token(BYTE);
8130                           name.append(" BYTE") ;
8131           break;
8132         default:
8133           jj_la1[104] = jj_gen;
8134           ;
8135         }
8136         jj_consume_token(7);
8137              name.append( ")") ;
8138       } else {
8139         ;
8140       }
8141       switch (jj_nt.kind) {
8142       case TO:
8143       case WITH:
8144       case CHARACTER:
8145         switch (jj_nt.kind) {
8146         case CHARACTER:
8147           jj_consume_token(CHARACTER);
8148           jj_consume_token(SET);
8149           characterSet = Name();
8150                                               name.append( " CHARACTER SET ") ;  name.append(characterSet.getImage()) ;
8151           break;
8152         default:
8153           jj_la1[105] = jj_gen;
8154           if (jj_2_35(4)) {
8155             jj_consume_token(WITH);
8156             jj_consume_token(LOCAL);
8157             jj_consume_token(TIME);
8158             jj_consume_token(ZONE);
8159                                              name.append(" WITH LOCAL TIME ZONE");
8160           } else if (jj_2_36(3)) {
8161             jj_consume_token(WITH);
8162             jj_consume_token(TIME);
8163             jj_consume_token(ZONE);
8164                                       name.append( " WITH TIME ZONE");
8165           } else if (jj_2_37(2)) {
8166             jj_consume_token(TO);
8167             jj_consume_token(MONTH);
8168                                name.append( " TO MONTH");
8169           } else if (jj_2_38(2)) {
8170             jj_consume_token(TO);
8171             jj_consume_token(SECOND);
8172                                 name.append( " TO SECOND");
8173             if (jj_2_34(2)) {
8174               jj_consume_token(5);
8175               precision = NumericLiteral();
8176                                                                        name.append( "(" + precision) ;
8177               jj_consume_token(7);
8178                                              name.append( ")");
8179             } else {
8180               ;
8181             }
8182           } else {
8183             jj_consume_token(-1);
8184             throw new ParseException();
8185           }
8186         }
8187         break;
8188       default:
8189         jj_la1[106] = jj_gen;
8190         ;
8191       }
8192         jjtree.closeNodeScope(jjtn000, true);
8193         jjtc000 = false;
8194         jjtn000.setImage(name.toString()) ;  {if (true) return jjtn000;}
8195     } catch (Throwable jjte000) {
8196           if (jjtc000) {
8197             jjtree.clearNodeScope(jjtn000);
8198             jjtc000 = false;
8199           } else {
8200             jjtree.popNode();
8201           }
8202           if (jjte000 instanceof RuntimeException) {
8203             {if (true) throw (RuntimeException)jjte000;}
8204           }
8205           if (jjte000 instanceof ParseException) {
8206             {if (true) throw (ParseException)jjte000;}
8207           }
8208           {if (true) throw (Error)jjte000;}
8209     } finally {
8210           if (jjtc000) {
8211             jjtree.closeNodeScope(jjtn000, true);
8212           }
8213     }
8214     throw new Error("Missing return statement in function");
8215   }
8216 
8217   final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8218  /*@bgen(jjtree) DateTimeLiteral */
8219  ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8220  boolean jjtc000 = true;
8221  jjtree.openNodeScope(jjtn000);Token t = null ;
8222  PLSQLNode simpleNode = null ;
8223  StringBuilder sb = new StringBuilder() ;
8224     try {
8225       switch (jj_nt.kind) {
8226       case INTERVAL:
8227         jj_consume_token(INTERVAL);
8228         break;
8229       case TIMESTAMP:
8230         jj_consume_token(TIMESTAMP);
8231         break;
8232       case DATE:
8233         jj_consume_token(DATE);
8234         break;
8235       default:
8236         jj_la1[107] = jj_gen;
8237         jj_consume_token(-1);
8238         throw new ParseException();
8239       }
8240           sb.append(token.image);
8241       switch (jj_nt.kind) {
8242       case CHARACTER_LITERAL:
8243         jj_consume_token(CHARACTER_LITERAL);
8244                                 sb.append(" ");  sb.append(token.image);
8245         break;
8246       case STRING_LITERAL:
8247         simpleNode = StringLiteral();
8248                                         sb.append(" ");  sb.append(simpleNode.getImage());
8249         break;
8250       default:
8251         jj_la1[108] = jj_gen;
8252         jj_consume_token(-1);
8253         throw new ParseException();
8254       }
8255       switch (jj_nt.kind) {
8256       case DAY:
8257       case HOUR:
8258       case MINUTE:
8259       case MONTH:
8260       case SECOND:
8261       case YEAR:
8262         switch (jj_nt.kind) {
8263         case YEAR:
8264           jj_consume_token(YEAR);
8265           break;
8266         case MONTH:
8267           jj_consume_token(MONTH);
8268           break;
8269         case DAY:
8270           jj_consume_token(DAY);
8271           break;
8272         case HOUR:
8273           jj_consume_token(HOUR);
8274           break;
8275         case MINUTE:
8276           jj_consume_token(MINUTE);
8277           break;
8278         case SECOND:
8279           jj_consume_token(SECOND);
8280           break;
8281         default:
8282           jj_la1[109] = jj_gen;
8283           jj_consume_token(-1);
8284           throw new ParseException();
8285         }
8286         break;
8287       default:
8288         jj_la1[110] = jj_gen;
8289         ;
8290       }
8291            if (null != t)
8292            {
8293             sb.append(" ");  sb.append(token.image);
8294             t = null;
8295            }
8296       if (jj_2_39(2)) {
8297         jj_consume_token(5);
8298         simpleNode = NumericLiteral();
8299                                                            sb.append("(");  sb.append(simpleNode.getImage());
8300         jj_consume_token(7);
8301                sb.append("}");
8302       } else {
8303         ;
8304       }
8305       switch (jj_nt.kind) {
8306       case TO:
8307       case WITH:
8308         switch (jj_nt.kind) {
8309         case WITH:
8310           jj_consume_token(WITH);
8311               sb.append(" "); sb.append(token.toString()) ;
8312           switch (jj_nt.kind) {
8313           case LOCAL:
8314             jj_consume_token(LOCAL);
8315                   sb.append(" "); sb.append(token.toString()) ;
8316             break;
8317           default:
8318             jj_la1[111] = jj_gen;
8319             ;
8320           }
8321           jj_consume_token(TIME);
8322           jj_consume_token(ZONE);
8323                     sb.append(" "); sb.append("TIME ZONE") ;
8324           break;
8325         case TO:
8326           jj_consume_token(TO);
8327             sb.append(" "); sb.append(token.toString()) ;
8328           switch (jj_nt.kind) {
8329           case YEAR:
8330             jj_consume_token(YEAR);
8331             break;
8332           case MONTH:
8333             jj_consume_token(MONTH);
8334             break;
8335           case DAY:
8336             jj_consume_token(DAY);
8337             break;
8338           case HOUR:
8339             jj_consume_token(HOUR);
8340             break;
8341           case MINUTE:
8342             jj_consume_token(MINUTE);
8343             break;
8344           case SECOND:
8345             jj_consume_token(SECOND);
8346             break;
8347           default:
8348             jj_la1[112] = jj_gen;
8349             jj_consume_token(-1);
8350             throw new ParseException();
8351           }
8352           sb.append(token.image);
8353           if (jj_2_40(2)) {
8354             jj_consume_token(5);
8355             simpleNode = NumericLiteral();
8356                                                            sb.append("(");  sb.append(simpleNode.getImage());
8357             jj_consume_token(7);
8358                 sb.append("}");
8359           } else {
8360             ;
8361           }
8362           break;
8363         default:
8364           jj_la1[113] = jj_gen;
8365           jj_consume_token(-1);
8366           throw new ParseException();
8367         }
8368         break;
8369       default:
8370         jj_la1[114] = jj_gen;
8371         ;
8372       }
8373      jjtree.closeNodeScope(jjtn000, true);
8374      jjtc000 = false;
8375     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
8376     } catch (Throwable jjte000) {
8377       if (jjtc000) {
8378         jjtree.clearNodeScope(jjtn000);
8379         jjtc000 = false;
8380       } else {
8381         jjtree.popNode();
8382       }
8383       if (jjte000 instanceof RuntimeException) {
8384         {if (true) throw (RuntimeException)jjte000;}
8385       }
8386       if (jjte000 instanceof ParseException) {
8387         {if (true) throw (ParseException)jjte000;}
8388       }
8389       {if (true) throw (Error)jjte000;}
8390     } finally {
8391       if (jjtc000) {
8392         jjtree.closeNodeScope(jjtn000, true);
8393       }
8394     }
8395     throw new Error("Missing return statement in function");
8396   }
8397 
8398   final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8399  /*@bgen(jjtree) ExceptionHandler */
8400   ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8401   boolean jjtc000 = true;
8402   jjtree.openNodeScope(jjtn000);
8403     try {
8404       jj_consume_token(EXCEPTION);
8405       label_20:
8406       while (true) {
8407         if (jj_2_41(2)) {
8408           ;
8409         } else {
8410           break label_20;
8411         }
8412         jj_consume_token(WHEN);
8413         QualifiedName();
8414         label_21:
8415         while (true) {
8416           switch (jj_nt.kind) {
8417           case OR:
8418             ;
8419             break;
8420           default:
8421             jj_la1[115] = jj_gen;
8422             break label_21;
8423           }
8424           jj_consume_token(OR);
8425           QualifiedName();
8426         }
8427         jj_consume_token(THEN);
8428         label_22:
8429         while (true) {
8430           Statement();
8431           switch (jj_nt.kind) {
8432           case 5:
8433           case 16:
8434           case 17:
8435           case 21:
8436           case REPLACE:
8437           case DEFINER:
8438           case CURRENT_USER:
8439           case LANGUAGE:
8440           case INLINE:
8441           case ADD:
8442           case AGGREGATE:
8443           case ARRAY:
8444           case AT:
8445           case ATTRIBUTE:
8446           case AUTHID:
8447           case BEGIN:
8448           case BODY:
8449           case BULK:
8450           case BYTE:
8451           case CASCADE:
8452           case CASE:
8453           case CLOSE:
8454           case COALESCE:
8455           case COLLECT:
8456           case COLUMN:
8457           case COMMENT:
8458           case COMMIT:
8459           case CONSTRUCTOR:
8460           case CONTINUE:
8461           case CONVERT:
8462           case CURRENT:
8463           case CURSOR:
8464           case DATA:
8465           case DATE:
8466           case DAY:
8467           case DECLARE:
8468           case DELETE:
8469           case DISABLE:
8470           case EDITIONABLE:
8471           case ELEMENT:
8472           case ENABLE:
8473           case ESCAPE:
8474           case EXCEPT:
8475           case EXCEPTIONS:
8476           case EXECUTE:
8477           case EXIT:
8478           case EXTERNAL:
8479           case EXTENDS:
8480           case EXTRACT:
8481           case FALSE:
8482           case FETCH:
8483           case FINAL:
8484           case FOR:
8485           case FORALL:
8486           case FORCE:
8487           case FUNCTION:
8488           case GLOBAL:
8489           case GOTO:
8490           case HASH:
8491           case HEAP:
8492           case HOUR:
8493           case IF:
8494           case IMMEDIATE:
8495           case INDICES:
8496           case INDEXTYPE:
8497           case INDICATOR:
8498           case INSERT:
8499           case INSTANTIABLE:
8500           case INTERVAL:
8501           case INVALIDATE:
8502           case ISOLATION:
8503           case JAVA:
8504           case LEVEL:
8505           case LIMIT:
8506           case LOCK:
8507           case LOOP:
8508           case MAP:
8509           case MAX:
8510           case MEMBER:
8511           case MERGE:
8512           case MIN:
8513           case MINUTE:
8514           case MLSLABEL:
8515           case MODIFY:
8516           case MOD:
8517           case MONTH:
8518           case NATURAL:
8519           case NEW:
8520           case NEW_DOT:
8521           case NO:
8522           case NONEDITIONABLE:
8523           case NOT:
8524           case NULL:
8525           case NULLIF:
8526           case OBJECT:
8527           case OID:
8528           case OPAQUE:
8529           case OPEN:
8530           case OPERATOR:
8531           case ORGANIZATION:
8532           case OTHERS:
8533           case OVERRIDING:
8534           case PACKAGE:
8535           case PARTITION:
8536           case PIPE:
8537           case PRAGMA:
8538           case PRESERVE:
8539           case PRIVATE:
8540           case PROCEDURE:
8541           case RAISE:
8542           case RANGE:
8543           case RAW:
8544           case REAL:
8545           case RECORD:
8546           case REF:
8547           case RELEASE:
8548           case RELIES_ON:
8549           case RENAME:
8550           case RESULT:
8551           case RETURN:
8552           case RETURNING:
8553           case REVERSE:
8554           case ROLLBACK:
8555           case ROW:
8556           case ROWS:
8557           case ROWID:
8558           case ROWNUM:
8559           case SAVE:
8560           case SAVEPOINT:
8561           case SECOND:
8562           case SELECT:
8563           case SELF:
8564           case SET:
8565           case SPACE:
8566           case SQL:
8567           case SQLCODE:
8568           case SQLERRM:
8569           case STATIC:
8570           case SUBTYPE:
8571           case SUBSTITUTABLE:
8572           case SUCCESSFUL:
8573           case SYSDATE:
8574           case SYS_REFCURSOR:
8575           case TEMPORARY:
8576           case TIME:
8577           case TIMESTAMP:
8578           case TIMEZONE_REGION:
8579           case TIMEZONE_ABBR:
8580           case TIMEZONE_MINUTE:
8581           case TIMEZONE_HOUR:
8582           case TRANSACTION:
8583           case TRUE:
8584           case TYPE:
8585           case UNDER:
8586           case USING:
8587           case WHILE:
8588           case YES:
8589           case SHOW:
8590           case A:
8591           case UPDATE:
8592           case DOUBLE:
8593           case DEC:
8594           case PRECISION:
8595           case INT:
8596           case NUMERIC:
8597           case NCHAR:
8598           case NVARCHAR2:
8599           case STRING:
8600           case UROWID:
8601           case VARRAY:
8602           case VARYING:
8603           case BFILE:
8604           case BLOB:
8605           case CLOB:
8606           case NCLOB:
8607           case YEAR:
8608           case LOCAL:
8609           case WITH:
8610           case ZONE:
8611           case CHARACTER:
8612           case AFTER:
8613           case BEFORE:
8614           case OLD:
8615           case PARENT:
8616           case CC_IF:
8617           case CC_ERROR:
8618           case ANALYZE:
8619           case ASSOCIATE:
8620           case AUDIT:
8621           case COMPOUND:
8622           case DATABASE:
8623           case CALL:
8624           case DDL:
8625           case DISASSOCIATE:
8626           case EACH:
8627           case FOLLOWS:
8628           case LOGOFF:
8629           case LOGON:
8630           case NESTED:
8631           case NOAUDIT:
8632           case SCHEMA:
8633           case SERVERERROR:
8634           case SHUTDOWN:
8635           case STARTUP:
8636           case STATEMENT:
8637           case STATISTICS:
8638           case SUSPEND:
8639           case TRUNCATE:
8640           case WRAPPED:
8641           case LIBRARY:
8642           case NAME:
8643           case STRUCT:
8644           case CONTEXT:
8645           case PARAMETERS:
8646           case LENGTH:
8647           case TDO:
8648           case MAXLEN:
8649           case CHARSETID:
8650           case CHARSETFORM:
8651           case ACCEPT:
8652           case ACCESSIBLE:
8653           case COPY:
8654           case DEFINE:
8655           case DISCONNECT:
8656           case HOST:
8657           case PRINT:
8658           case QUIT:
8659           case REMARK:
8660           case UNDEFINE:
8661           case VARIABLE:
8662           case WHENEVER:
8663           case ATTACH:
8664           case CAST:
8665           case TREAT:
8666           case TRIM:
8667           case LEFT:
8668           case RIGHT:
8669           case BOTH:
8670           case EMPTY:
8671           case MULTISET:
8672           case SUBMULTISET:
8673           case LEADING:
8674           case TRAILING:
8675           case CHAR_CS:
8676           case NCHAR_CS:
8677           case DBTIMEZONE:
8678           case SESSIONTIMEZONE:
8679           case AUTHENTICATED:
8680           case LINK:
8681           case SHARED:
8682           case DIRECTORY:
8683           case USER:
8684           case IDENTIFIER:
8685           case UNSIGNED_NUMERIC_LITERAL:
8686           case CHARACTER_LITERAL:
8687           case STRING_LITERAL:
8688           case QUOTED_LITERAL:
8689             ;
8690             break;
8691           default:
8692             jj_la1[116] = jj_gen;
8693             break label_22;
8694           }
8695         }
8696       }
8697       switch (jj_nt.kind) {
8698       case WHEN:
8699         jj_consume_token(WHEN);
8700         jj_consume_token(OTHERS);
8701         jj_consume_token(THEN);
8702         label_23:
8703         while (true) {
8704           Statement();
8705           switch (jj_nt.kind) {
8706           case 5:
8707           case 16:
8708           case 17:
8709           case 21:
8710           case REPLACE:
8711           case DEFINER:
8712           case CURRENT_USER:
8713           case LANGUAGE:
8714           case INLINE:
8715           case ADD:
8716           case AGGREGATE:
8717           case ARRAY:
8718           case AT:
8719           case ATTRIBUTE:
8720           case AUTHID:
8721           case BEGIN:
8722           case BODY:
8723           case BULK:
8724           case BYTE:
8725           case CASCADE:
8726           case CASE:
8727           case CLOSE:
8728           case COALESCE:
8729           case COLLECT:
8730           case COLUMN:
8731           case COMMENT:
8732           case COMMIT:
8733           case CONSTRUCTOR:
8734           case CONTINUE:
8735           case CONVERT:
8736           case CURRENT:
8737           case CURSOR:
8738           case DATA:
8739           case DATE:
8740           case DAY:
8741           case DECLARE:
8742           case DELETE:
8743           case DISABLE:
8744           case EDITIONABLE:
8745           case ELEMENT:
8746           case ENABLE:
8747           case ESCAPE:
8748           case EXCEPT:
8749           case EXCEPTIONS:
8750           case EXECUTE:
8751           case EXIT:
8752           case EXTERNAL:
8753           case EXTENDS:
8754           case EXTRACT:
8755           case FALSE:
8756           case FETCH:
8757           case FINAL:
8758           case FOR:
8759           case FORALL:
8760           case FORCE:
8761           case FUNCTION:
8762           case GLOBAL:
8763           case GOTO:
8764           case HASH:
8765           case HEAP:
8766           case HOUR:
8767           case IF:
8768           case IMMEDIATE:
8769           case INDICES:
8770           case INDEXTYPE:
8771           case INDICATOR:
8772           case INSERT:
8773           case INSTANTIABLE:
8774           case INTERVAL:
8775           case INVALIDATE:
8776           case ISOLATION:
8777           case JAVA:
8778           case LEVEL:
8779           case LIMIT:
8780           case LOCK:
8781           case LOOP:
8782           case MAP:
8783           case MAX:
8784           case MEMBER:
8785           case MERGE:
8786           case MIN:
8787           case MINUTE:
8788           case MLSLABEL:
8789           case MODIFY:
8790           case MOD:
8791           case MONTH:
8792           case NATURAL:
8793           case NEW:
8794           case NEW_DOT:
8795           case NO:
8796           case NONEDITIONABLE:
8797           case NOT:
8798           case NULL:
8799           case NULLIF:
8800           case OBJECT:
8801           case OID:
8802           case OPAQUE:
8803           case OPEN:
8804           case OPERATOR:
8805           case ORGANIZATION:
8806           case OTHERS:
8807           case OVERRIDING:
8808           case PACKAGE:
8809           case PARTITION:
8810           case PIPE:
8811           case PRAGMA:
8812           case PRESERVE:
8813           case PRIVATE:
8814           case PROCEDURE:
8815           case RAISE:
8816           case RANGE:
8817           case RAW:
8818           case REAL:
8819           case RECORD:
8820           case REF:
8821           case RELEASE:
8822           case RELIES_ON:
8823           case RENAME:
8824           case RESULT:
8825           case RETURN:
8826           case RETURNING:
8827           case REVERSE:
8828           case ROLLBACK:
8829           case ROW:
8830           case ROWS:
8831           case ROWID:
8832           case ROWNUM:
8833           case SAVE:
8834           case SAVEPOINT:
8835           case SECOND:
8836           case SELECT:
8837           case SELF:
8838           case SET:
8839           case SPACE:
8840           case SQL:
8841           case SQLCODE:
8842           case SQLERRM:
8843           case STATIC:
8844           case SUBTYPE:
8845           case SUBSTITUTABLE:
8846           case SUCCESSFUL:
8847           case SYSDATE:
8848           case SYS_REFCURSOR:
8849           case TEMPORARY:
8850           case TIME:
8851           case TIMESTAMP:
8852           case TIMEZONE_REGION:
8853           case TIMEZONE_ABBR:
8854           case TIMEZONE_MINUTE:
8855           case TIMEZONE_HOUR:
8856           case TRANSACTION:
8857           case TRUE:
8858           case TYPE:
8859           case UNDER:
8860           case USING:
8861           case WHILE:
8862           case YES:
8863           case SHOW:
8864           case A:
8865           case UPDATE:
8866           case DOUBLE:
8867           case DEC:
8868           case PRECISION:
8869           case INT:
8870           case NUMERIC:
8871           case NCHAR:
8872           case NVARCHAR2:
8873           case STRING:
8874           case UROWID:
8875           case VARRAY:
8876           case VARYING:
8877           case BFILE:
8878           case BLOB:
8879           case CLOB:
8880           case NCLOB:
8881           case YEAR:
8882           case LOCAL:
8883           case WITH:
8884           case ZONE:
8885           case CHARACTER:
8886           case AFTER:
8887           case BEFORE:
8888           case OLD:
8889           case PARENT:
8890           case CC_IF:
8891           case CC_ERROR:
8892           case ANALYZE:
8893           case ASSOCIATE:
8894           case AUDIT:
8895           case COMPOUND:
8896           case DATABASE:
8897           case CALL:
8898           case DDL:
8899           case DISASSOCIATE:
8900           case EACH:
8901           case FOLLOWS:
8902           case LOGOFF:
8903           case LOGON:
8904           case NESTED:
8905           case NOAUDIT:
8906           case SCHEMA:
8907           case SERVERERROR:
8908           case SHUTDOWN:
8909           case STARTUP:
8910           case STATEMENT:
8911           case STATISTICS:
8912           case SUSPEND:
8913           case TRUNCATE:
8914           case WRAPPED:
8915           case LIBRARY:
8916           case NAME:
8917           case STRUCT:
8918           case CONTEXT:
8919           case PARAMETERS:
8920           case LENGTH:
8921           case TDO:
8922           case MAXLEN:
8923           case CHARSETID:
8924           case CHARSETFORM:
8925           case ACCEPT:
8926           case ACCESSIBLE:
8927           case COPY:
8928           case DEFINE:
8929           case DISCONNECT:
8930           case HOST:
8931           case PRINT:
8932           case QUIT:
8933           case REMARK:
8934           case UNDEFINE:
8935           case VARIABLE:
8936           case WHENEVER:
8937           case ATTACH:
8938           case CAST:
8939           case TREAT:
8940           case TRIM:
8941           case LEFT:
8942           case RIGHT:
8943           case BOTH:
8944           case EMPTY:
8945           case MULTISET:
8946           case SUBMULTISET:
8947           case LEADING:
8948           case TRAILING:
8949           case CHAR_CS:
8950           case NCHAR_CS:
8951           case DBTIMEZONE:
8952           case SESSIONTIMEZONE:
8953           case AUTHENTICATED:
8954           case LINK:
8955           case SHARED:
8956           case DIRECTORY:
8957           case USER:
8958           case IDENTIFIER:
8959           case UNSIGNED_NUMERIC_LITERAL:
8960           case CHARACTER_LITERAL:
8961           case STRING_LITERAL:
8962           case QUOTED_LITERAL:
8963             ;
8964             break;
8965           default:
8966             jj_la1[117] = jj_gen;
8967             break label_23;
8968           }
8969         }
8970         break;
8971       default:
8972         jj_la1[118] = jj_gen;
8973         ;
8974       }
8975         jjtree.closeNodeScope(jjtn000, true);
8976         jjtc000 = false;
8977         {if (true) return jjtn000 ;}
8978     } catch (Throwable jjte000) {
8979         if (jjtc000) {
8980           jjtree.clearNodeScope(jjtn000);
8981           jjtc000 = false;
8982         } else {
8983           jjtree.popNode();
8984         }
8985         if (jjte000 instanceof RuntimeException) {
8986           {if (true) throw (RuntimeException)jjte000;}
8987         }
8988         if (jjte000 instanceof ParseException) {
8989           {if (true) throw (ParseException)jjte000;}
8990         }
8991         {if (true) throw (Error)jjte000;}
8992     } finally {
8993         if (jjtc000) {
8994           jjtree.closeNodeScope(jjtn000, true);
8995         }
8996     }
8997     throw new Error("Missing return statement in function");
8998   }
8999 
9000   final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
9001  /*@bgen(jjtree) Skip2NextTerminator */
9002   ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
9003   boolean jjtc000 = true;
9004   jjtree.openNodeScope(jjtn000);Token beginToken = getToken(0);
9005   Token t = getToken(1);
9006   int count = (initiator == null) ? 0 : 1;
9007   if(t.image.equals(initiator)) count++;
9008   while (count > 0 || !t.image.equals(terminator))
9009   {
9010     t = getNextToken();
9011     t = getToken(1);
9012           if(t.image.equals(initiator)) count++;
9013           if(t.image.equals(terminator)) count--;
9014     if((null != t.specialToken && beginToken.kind != SELECT && beginToken.kind != INSERT && beginToken.kind != UPDATE && beginToken.kind != DELETE && beginToken.kind != MERGE) || t.kind == EOF)
9015         return;
9016     if (t.specialToken != null && "/".equals(t.image))
9017             return;
9018   }
9019     try {
9020           jjtree.closeNodeScope(jjtn000, true);
9021           jjtc000 = false;
9022           {if (true) return;}
9023     } finally {
9024           if (jjtc000) {
9025             jjtree.closeNodeScope(jjtn000, true);
9026           }
9027     }
9028   }
9029 
9030 /*
9031  Read Tokens up to but not including the target String. 
9032 */
9033   final public void Skip2NextOccurrence(String target) throws ParseException {
9034  /*@bgen(jjtree) Skip2NextOccurrence */
9035   ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
9036   boolean jjtc000 = true;
9037   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9038   while (!nextToken.image.equals(target)
9039          && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) ) //In case the target is a Special Token
9040          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9041         )
9042   {
9043     nextToken = getNextToken();
9044     nextToken = getToken(1);
9045   }
9046     try {
9047           jjtree.closeNodeScope(jjtn000, true);
9048           jjtc000 = false;
9049           {if (true) return;}
9050     } finally {
9051           if (jjtc000) {
9052             jjtree.closeNodeScope(jjtn000, true);
9053           }
9054     }
9055   }
9056 
9057 /*
9058  Read Tokens up to and including the target String. 
9059 */
9060   final public void SkipPastNextOccurrence(String target) throws ParseException {
9061  /*@bgen(jjtree) SkipPastNextOccurrence */
9062   ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9063   boolean jjtc000 = true;
9064   jjtree.openNodeScope(jjtn000);Token t = null;
9065   Skip2NextOccurrence(target) ;
9066   t = getNextToken();
9067     try {
9068           jjtree.closeNodeScope(jjtn000, true);
9069           jjtc000 = false;
9070           {if (true) return;}
9071     } finally {
9072           if (jjtc000) {
9073             jjtree.closeNodeScope(jjtn000, true);
9074           }
9075     }
9076   }
9077 
9078 /*
9079  Read Tokens up to but not including the target Token.kind. 
9080 */
9081   final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9082  /*@bgen(jjtree) Skip2NextTokenOccurrence */
9083   ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9084   boolean jjtc000 = true;
9085   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9086   Token specToken = null ;
9087   while (nextToken.kind!=target
9088          && (null == nextToken.specialToken || nextToken.specialToken.kind!=target ) //In case the target is a Special Token
9089          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9090         )
9091   {
9092     /*
9093 	Check if the target appears as a SpecialToken 
9094 
9095 
9096 	nextToken.specialToken points to the _LAST_ of any SpecialTokens before the current normal Token.
9097 
9098 	It is the head of a doubly-linked list:
9099 
9100 	The ${specialToken}.specialToken field POINTS BACKWARDS TOWARDS the FIRST occurring SpecialToken
9101 	The ${specialToken}.next field POINTS FORWARDS to to the LAST occurring SpecialToken
9102 
9103 	This means that if the program is interested in a specific SpecialToken, it must examine the linked list for every Token which has nexToken.specialToken != null.
9104     
9105     */
9106     specToken = nextToken.specialToken;
9107     if (null!= specToken)
9108     {
9109         //Walk backwards through the list looking for this Token as a Special Token 
9110         while (specToken != null && specToken.kind != target)
9111         {
9112                 specToken = specToken.specialToken;
9113         }
9114 
9115         //We have found the target as a SpecialToken - break out of normal Token search
9116         if (null != specToken && specToken.kind == target)
9117         {
9118                 break;
9119         }
9120     }
9121 
9122     nextToken = getNextToken();
9123     nextToken = getToken(1);
9124   }
9125     try {
9126           jjtree.closeNodeScope(jjtn000, true);
9127           jjtc000 = false;
9128           {if (true) return;}
9129     } finally {
9130           if (jjtc000) {
9131             jjtree.closeNodeScope(jjtn000, true);
9132           }
9133     }
9134   }
9135 
9136 /*
9137  Read Tokens up to and including the target Token.kind. 
9138 */
9139   final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9140  /*@bgen(jjtree) SkipPastNextTokenOccurrence */
9141   ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9142   boolean jjtc000 = true;
9143   jjtree.openNodeScope(jjtn000);Token t = null;
9144   Skip2NextTokenOccurrence(target) ;
9145   t = getNextToken();
9146     try {
9147           jjtree.closeNodeScope(jjtn000, true);
9148           jjtc000 = false;
9149           {if (true) return;}
9150     } finally {
9151           if (jjtc000) {
9152             jjtree.closeNodeScope(jjtn000, true);
9153           }
9154     }
9155   }
9156 
9157 /*
9158  Read Tokens up to but not including the target String. 
9159 */
9160   final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9161  /*@bgen(jjtree) Read2NextOccurrence */
9162   ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9163   boolean jjtc000 = true;
9164   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9165   Token nextToken = getToken(1);
9166   while (!nextToken.image.equals(target)
9167          && nextToken.kind!=EOF
9168         )
9169   {
9170     nextToken = getNextToken();
9171     sb.append(nextToken.image);
9172     nextToken = getToken(1);
9173   }
9174     try {
9175           jjtree.closeNodeScope(jjtn000, true);
9176           jjtc000 = false;
9177           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9178     } finally {
9179           if (jjtc000) {
9180             jjtree.closeNodeScope(jjtn000, true);
9181           }
9182     }
9183     throw new Error("Missing return statement in function");
9184   }
9185 
9186 /*
9187  Read Tokens up to and including the target String. 
9188 */
9189   final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9190  /*@bgen(jjtree) ReadPastNextOccurrence */
9191   ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9192   boolean jjtc000 = true;
9193   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9194   Token t = null;
9195   sb.append(Read2NextOccurrence(target)) ;
9196   t = getNextToken(); // Chomp this one 
9197   sb.append(t.image);
9198     try {
9199           jjtree.closeNodeScope(jjtn000, true);
9200           jjtc000 = false;
9201           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9202     } finally {
9203           if (jjtc000) {
9204             jjtree.closeNodeScope(jjtn000, true);
9205           }
9206     }
9207     throw new Error("Missing return statement in function");
9208   }
9209 
9210 /**
9211  * 2006-05-24 - Matthias Hendler - added MERGE
9212  */
9213   final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9214  /*@bgen(jjtree) SqlStatement */
9215   ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9216   boolean jjtc000 = true;
9217   jjtree.openNodeScope(jjtn000);
9218     try {
9219       switch (jj_nt.kind) {
9220       case SELECT:
9221         jj_consume_token(SELECT);
9222         break;
9223       case UPDATE:
9224         jj_consume_token(UPDATE);
9225         break;
9226       case INSERT:
9227         jj_consume_token(INSERT);
9228         break;
9229       case DELETE:
9230         jj_consume_token(DELETE);
9231         break;
9232       case COMMIT:
9233         jj_consume_token(COMMIT);
9234         break;
9235       case ROLLBACK:
9236         jj_consume_token(ROLLBACK);
9237         break;
9238       case SAVEPOINT:
9239         jj_consume_token(SAVEPOINT);
9240         break;
9241       case EXECUTE:
9242         jj_consume_token(EXECUTE);
9243         break;
9244       case SET:
9245         jj_consume_token(SET);
9246         jj_consume_token(TRANSACTION);
9247         break;
9248       case LOCK:
9249         jj_consume_token(LOCK);
9250         jj_consume_token(TABLE);
9251         break;
9252       case MERGE:
9253         jj_consume_token(MERGE);
9254         break;
9255       case WITH:
9256         jj_consume_token(WITH);
9257         break;
9258       default:
9259         jj_la1[119] = jj_gen;
9260         jj_consume_token(-1);
9261         throw new ParseException();
9262       }
9263       Skip2NextTerminator(initiator,terminator);
9264           jjtree.closeNodeScope(jjtn000, true);
9265           jjtc000 = false;
9266           {if (true) return jjtn000 ;}
9267     } catch (Throwable jjte000) {
9268           if (jjtc000) {
9269             jjtree.clearNodeScope(jjtn000);
9270             jjtc000 = false;
9271           } else {
9272             jjtree.popNode();
9273           }
9274           if (jjte000 instanceof RuntimeException) {
9275             {if (true) throw (RuntimeException)jjte000;}
9276           }
9277           if (jjte000 instanceof ParseException) {
9278             {if (true) throw (ParseException)jjte000;}
9279           }
9280           {if (true) throw (Error)jjte000;}
9281     } finally {
9282           if (jjtc000) {
9283             jjtree.closeNodeScope(jjtn000, true);
9284           }
9285     }
9286     throw new Error("Missing return statement in function");
9287   }
9288 
9289 /**
9290  * 2011-05-15 - SRT - Added to cope with wrapped objects
9291   A wrapped function looks like this (always terminated by one or more equals signs "="):-
9292   
9293   <pre>
9294   "  CREATE OR REPLACE FUNCTION "TESTUSER"."GET_DATE_STRING"
9295 / ** Return SYSDATE formatted using the provided template.
9296  *
9297  *
9298  *  &#64;param p_date_format normal TO_CHARE/TO_DATE date template
9299  *  &#64;return formatted datestring
9300  *  &#64;see http://www.oracle-base.com/articles/10g/WrapAndDBMS_DDL_10gR2.php#dbms_ddl
9301  * /
9302 wrapped
9303 a000000
9304 369
9305 abcd
9306 abcd
9307 abcd
9308 abcd
9309 abcd
9310 abcd
9311 abcd
9312 abcd
9313 abcd
9314 abcd
9315 abcd
9316 abcd
9317 abcd
9318 abcd
9319 abcd
9320 8
9321 89 b6
9322 /SBrhM8+1iUO4QAih+qD2SK8kSowg8eZgcfLCNL+XlquYvSuoVah8JbRPpdHDLHn479SdFLw
9323 v04omzJ0zOfHdMAzuHQlw+fAsr2ym9YI8I521pRTbnFVAHOOUw4JqPkIyj7wj4VwyL17nhYb
9324 3qPVuL6SvhZTmEBnRtaErHpzaDuIpqZ0G4s=
9325   "
9326   </pre>
9327  */
9328   final public void WrappedObject() throws ParseException {
9329  /*@bgen(jjtree) WrappedObject */
9330   ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9331   boolean jjtc000 = true;
9332   jjtree.openNodeScope(jjtn000);
9333     try {
9334       jj_consume_token(WRAPPED);
9335           jjtree.closeNodeScope(jjtn000, true);
9336           jjtc000 = false;
9337            Token nextToken;
9338 
9339                 nextToken = getToken(1); //ReadAhead
9340                 while (
9341                      null != nextToken && nextToken.kind!=EOF
9342                      )
9343                 {
9344                         nextToken = getNextToken();
9345 
9346                         //Execute manual readahead 
9347                         nextToken = getToken(1); //ReadAhead 1 Token 
9348                 }
9349                 {if (true) return;}
9350     } finally {
9351           if (jjtc000) {
9352             jjtree.closeNodeScope(jjtn000, true);
9353           }
9354     }
9355   }
9356 
9357 // ============================================================================
9358 // S T A T E M E N T S
9359 // ============================================================================
9360 
9361 /**
9362  * 2006-05-24 - Matthias Hendler - added MERGE, EXECUTE choice and LOOKAHEAD at &lt;LOOP&gt;
9363  */
9364   final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9365  /*@bgen(jjtree) UnlabelledStatement */
9366   ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9367   boolean jjtc000 = true;
9368   jjtree.openNodeScope(jjtn000);
9369     try {
9370       if (jj_2_42(2147483647)) {
9371         SqlStatement(null,";");
9372         switch (jj_nt.kind) {
9373         case 4:
9374           jj_consume_token(4);
9375           break;
9376         default:
9377           jj_la1[120] = jj_gen;
9378           ;
9379         }
9380       } else if (jj_2_43(3)) {
9381         ContinueStatement();
9382         jj_consume_token(4);
9383       } else {
9384         switch (jj_nt.kind) {
9385         case CASE:
9386           CaseStatement();
9387           jj_consume_token(4);
9388           break;
9389         case IF:
9390           IfStatement();
9391           jj_consume_token(4);
9392           break;
9393         case FOR:
9394           ForStatement();
9395           jj_consume_token(4);
9396           break;
9397         case FORALL:
9398           ForAllStatement();
9399           jj_consume_token(4);
9400           break;
9401         case LOOP:
9402           LoopStatement();
9403           jj_consume_token(4);
9404           break;
9405         case WHILE:
9406           WhileStatement();
9407           jj_consume_token(4);
9408           break;
9409         case GOTO:
9410           GotoStatement();
9411           jj_consume_token(4);
9412           break;
9413         case RETURN:
9414           ReturnStatement();
9415           jj_consume_token(4);
9416           break;
9417         case EXIT:
9418           ExitStatement();
9419           jj_consume_token(4);
9420           break;
9421         case RAISE:
9422           RaiseStatement();
9423           jj_consume_token(4);
9424           break;
9425         case CLOSE:
9426           CloseStatement();
9427           jj_consume_token(4);
9428           break;
9429         case OPEN:
9430           OpenStatement();
9431           jj_consume_token(4);
9432           break;
9433         case FETCH:
9434           FetchStatement();
9435           jj_consume_token(4);
9436           break;
9437         case BEGIN:
9438         case DECLARE:
9439           Block();
9440           jj_consume_token(4);
9441           break;
9442         case EXECUTE:
9443           EmbeddedSqlStatement();
9444           jj_consume_token(4);
9445           break;
9446         case PIPE:
9447           PipelineStatement();
9448           jj_consume_token(4);
9449           break;
9450         case CC_IF:
9451         case CC_ERROR:
9452           ConditionalCompilationStatement();
9453           break;
9454         case PRAGMA:
9455           InlinePragma();
9456           jj_consume_token(4);
9457           break;
9458         case 5:
9459         case 16:
9460         case 17:
9461         case REPLACE:
9462         case DEFINER:
9463         case CURRENT_USER:
9464         case LANGUAGE:
9465         case INLINE:
9466         case ADD:
9467         case AGGREGATE:
9468         case ARRAY:
9469         case AT:
9470         case ATTRIBUTE:
9471         case AUTHID:
9472         case BODY:
9473         case BULK:
9474         case BYTE:
9475         case CASCADE:
9476         case COALESCE:
9477         case COLLECT:
9478         case COLUMN:
9479         case COMMENT:
9480         case COMMIT:
9481         case CONSTRUCTOR:
9482         case CONTINUE:
9483         case CONVERT:
9484         case CURRENT:
9485         case CURSOR:
9486         case DATA:
9487         case DATE:
9488         case DAY:
9489         case DISABLE:
9490         case EDITIONABLE:
9491         case ELEMENT:
9492         case ENABLE:
9493         case ESCAPE:
9494         case EXCEPT:
9495         case EXCEPTIONS:
9496         case EXTERNAL:
9497         case EXTENDS:
9498         case EXTRACT:
9499         case FALSE:
9500         case FINAL:
9501         case FORCE:
9502         case FUNCTION:
9503         case GLOBAL:
9504         case HASH:
9505         case HEAP:
9506         case HOUR:
9507         case IMMEDIATE:
9508         case INDICES:
9509         case INDEXTYPE:
9510         case INDICATOR:
9511         case INSTANTIABLE:
9512         case INTERVAL:
9513         case INVALIDATE:
9514         case ISOLATION:
9515         case JAVA:
9516         case LEVEL:
9517         case LIMIT:
9518         case MAP:
9519         case MAX:
9520         case MEMBER:
9521         case MERGE:
9522         case MIN:
9523         case MINUTE:
9524         case MLSLABEL:
9525         case MODIFY:
9526         case MOD:
9527         case MONTH:
9528         case NATURAL:
9529         case NEW:
9530         case NEW_DOT:
9531         case NO:
9532         case NONEDITIONABLE:
9533         case NOT:
9534         case NULL:
9535         case NULLIF:
9536         case OBJECT:
9537         case OID:
9538         case OPAQUE:
9539         case OPERATOR:
9540         case ORGANIZATION:
9541         case OTHERS:
9542         case OVERRIDING:
9543         case PACKAGE:
9544         case PARTITION:
9545         case PRESERVE:
9546         case PRIVATE:
9547         case PROCEDURE:
9548         case RANGE:
9549         case RAW:
9550         case REAL:
9551         case RECORD:
9552         case REF:
9553         case RELEASE:
9554         case RELIES_ON:
9555         case RENAME:
9556         case RESULT:
9557         case RETURNING:
9558         case REVERSE:
9559         case ROLLBACK:
9560         case ROW:
9561         case ROWS:
9562         case ROWID:
9563         case ROWNUM:
9564         case SAVE:
9565         case SAVEPOINT:
9566         case SECOND:
9567         case SELECT:
9568         case SELF:
9569         case SET:
9570         case SPACE:
9571         case SQL:
9572         case SQLCODE:
9573         case SQLERRM:
9574         case STATIC:
9575         case SUBTYPE:
9576         case SUBSTITUTABLE:
9577         case SUCCESSFUL:
9578         case SYSDATE:
9579         case SYS_REFCURSOR:
9580         case TEMPORARY:
9581         case TIME:
9582         case TIMESTAMP:
9583         case TIMEZONE_REGION:
9584         case TIMEZONE_ABBR:
9585         case TIMEZONE_MINUTE:
9586         case TIMEZONE_HOUR:
9587         case TRANSACTION:
9588         case TRUE:
9589         case TYPE:
9590         case UNDER:
9591         case USING:
9592         case YES:
9593         case SHOW:
9594         case A:
9595         case DOUBLE:
9596         case DEC:
9597         case PRECISION:
9598         case INT:
9599         case NUMERIC:
9600         case NCHAR:
9601         case NVARCHAR2:
9602         case STRING:
9603         case UROWID:
9604         case VARRAY:
9605         case VARYING:
9606         case BFILE:
9607         case BLOB:
9608         case CLOB:
9609         case NCLOB:
9610         case YEAR:
9611         case LOCAL:
9612         case WITH:
9613         case ZONE:
9614         case CHARACTER:
9615         case AFTER:
9616         case BEFORE:
9617         case OLD:
9618         case PARENT:
9619         case ANALYZE:
9620         case ASSOCIATE:
9621         case AUDIT:
9622         case COMPOUND:
9623         case DATABASE:
9624         case CALL:
9625         case DDL:
9626         case DISASSOCIATE:
9627         case EACH:
9628         case FOLLOWS:
9629         case LOGOFF:
9630         case LOGON:
9631         case NESTED:
9632         case NOAUDIT:
9633         case SCHEMA:
9634         case SERVERERROR:
9635         case SHUTDOWN:
9636         case STARTUP:
9637         case STATEMENT:
9638         case STATISTICS:
9639         case SUSPEND:
9640         case TRUNCATE:
9641         case WRAPPED:
9642         case LIBRARY:
9643         case NAME:
9644         case STRUCT:
9645         case CONTEXT:
9646         case PARAMETERS:
9647         case LENGTH:
9648         case TDO:
9649         case MAXLEN:
9650         case CHARSETID:
9651         case CHARSETFORM:
9652         case ACCEPT:
9653         case ACCESSIBLE:
9654         case COPY:
9655         case DEFINE:
9656         case DISCONNECT:
9657         case HOST:
9658         case PRINT:
9659         case QUIT:
9660         case REMARK:
9661         case UNDEFINE:
9662         case VARIABLE:
9663         case WHENEVER:
9664         case ATTACH:
9665         case CAST:
9666         case TREAT:
9667         case TRIM:
9668         case LEFT:
9669         case RIGHT:
9670         case BOTH:
9671         case EMPTY:
9672         case MULTISET:
9673         case SUBMULTISET:
9674         case LEADING:
9675         case TRAILING:
9676         case CHAR_CS:
9677         case NCHAR_CS:
9678         case DBTIMEZONE:
9679         case SESSIONTIMEZONE:
9680         case AUTHENTICATED:
9681         case LINK:
9682         case SHARED:
9683         case DIRECTORY:
9684         case USER:
9685         case IDENTIFIER:
9686         case UNSIGNED_NUMERIC_LITERAL:
9687         case CHARACTER_LITERAL:
9688         case STRING_LITERAL:
9689         case QUOTED_LITERAL:
9690           Expression();
9691           jj_consume_token(4);
9692           break;
9693         default:
9694           jj_la1[121] = jj_gen;
9695           jj_consume_token(-1);
9696           throw new ParseException();
9697         }
9698       }
9699         jjtree.closeNodeScope(jjtn000, true);
9700         jjtc000 = false;
9701         {if (true) return jjtn000 ;}
9702     } catch (Throwable jjte000) {
9703          if (jjtc000) {
9704            jjtree.clearNodeScope(jjtn000);
9705            jjtc000 = false;
9706          } else {
9707            jjtree.popNode();
9708          }
9709          if (jjte000 instanceof RuntimeException) {
9710            {if (true) throw (RuntimeException)jjte000;}
9711          }
9712          if (jjte000 instanceof ParseException) {
9713            {if (true) throw (ParseException)jjte000;}
9714          }
9715          {if (true) throw (Error)jjte000;}
9716     } finally {
9717          if (jjtc000) {
9718            jjtree.closeNodeScope(jjtn000, true);
9719          }
9720     }
9721     throw new Error("Missing return statement in function");
9722   }
9723 
9724   final public ASTStatement Statement() throws ParseException {
9725  /*@bgen(jjtree) Statement */
9726   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9727   boolean jjtc000 = true;
9728   jjtree.openNodeScope(jjtn000);
9729     try {
9730       switch (jj_nt.kind) {
9731       case 21:
9732         LabelledStatement();
9733         break;
9734       case 5:
9735       case 16:
9736       case 17:
9737       case REPLACE:
9738       case DEFINER:
9739       case CURRENT_USER:
9740       case LANGUAGE:
9741       case INLINE:
9742       case ADD:
9743       case AGGREGATE:
9744       case ARRAY:
9745       case AT:
9746       case ATTRIBUTE:
9747       case AUTHID:
9748       case BEGIN:
9749       case BODY:
9750       case BULK:
9751       case BYTE:
9752       case CASCADE:
9753       case CASE:
9754       case CLOSE:
9755       case COALESCE:
9756       case COLLECT:
9757       case COLUMN:
9758       case COMMENT:
9759       case COMMIT:
9760       case CONSTRUCTOR:
9761       case CONTINUE:
9762       case CONVERT:
9763       case CURRENT:
9764       case CURSOR:
9765       case DATA:
9766       case DATE:
9767       case DAY:
9768       case DECLARE:
9769       case DELETE:
9770       case DISABLE:
9771       case EDITIONABLE:
9772       case ELEMENT:
9773       case ENABLE:
9774       case ESCAPE:
9775       case EXCEPT:
9776       case EXCEPTIONS:
9777       case EXECUTE:
9778       case EXIT:
9779       case EXTERNAL:
9780       case EXTENDS:
9781       case EXTRACT:
9782       case FALSE:
9783       case FETCH:
9784       case FINAL:
9785       case FOR:
9786       case FORALL:
9787       case FORCE:
9788       case FUNCTION:
9789       case GLOBAL:
9790       case GOTO:
9791       case HASH:
9792       case HEAP:
9793       case HOUR:
9794       case IF:
9795       case IMMEDIATE:
9796       case INDICES:
9797       case INDEXTYPE:
9798       case INDICATOR:
9799       case INSERT:
9800       case INSTANTIABLE:
9801       case INTERVAL:
9802       case INVALIDATE:
9803       case ISOLATION:
9804       case JAVA:
9805       case LEVEL:
9806       case LIMIT:
9807       case LOCK:
9808       case LOOP:
9809       case MAP:
9810       case MAX:
9811       case MEMBER:
9812       case MERGE:
9813       case MIN:
9814       case MINUTE:
9815       case MLSLABEL:
9816       case MODIFY:
9817       case MOD:
9818       case MONTH:
9819       case NATURAL:
9820       case NEW:
9821       case NEW_DOT:
9822       case NO:
9823       case NONEDITIONABLE:
9824       case NOT:
9825       case NULL:
9826       case NULLIF:
9827       case OBJECT:
9828       case OID:
9829       case OPAQUE:
9830       case OPEN:
9831       case OPERATOR:
9832       case ORGANIZATION:
9833       case OTHERS:
9834       case OVERRIDING:
9835       case PACKAGE:
9836       case PARTITION:
9837       case PIPE:
9838       case PRAGMA:
9839       case PRESERVE:
9840       case PRIVATE:
9841       case PROCEDURE:
9842       case RAISE:
9843       case RANGE:
9844       case RAW:
9845       case REAL:
9846       case RECORD:
9847       case REF:
9848       case RELEASE:
9849       case RELIES_ON:
9850       case RENAME:
9851       case RESULT:
9852       case RETURN:
9853       case RETURNING:
9854       case REVERSE:
9855       case ROLLBACK:
9856       case ROW:
9857       case ROWS:
9858       case ROWID:
9859       case ROWNUM:
9860       case SAVE:
9861       case SAVEPOINT:
9862       case SECOND:
9863       case SELECT:
9864       case SELF:
9865       case SET:
9866       case SPACE:
9867       case SQL:
9868       case SQLCODE:
9869       case SQLERRM:
9870       case STATIC:
9871       case SUBTYPE:
9872       case SUBSTITUTABLE:
9873       case SUCCESSFUL:
9874       case SYSDATE:
9875       case SYS_REFCURSOR:
9876       case TEMPORARY:
9877       case TIME:
9878       case TIMESTAMP:
9879       case TIMEZONE_REGION:
9880       case TIMEZONE_ABBR:
9881       case TIMEZONE_MINUTE:
9882       case TIMEZONE_HOUR:
9883       case TRANSACTION:
9884       case TRUE:
9885       case TYPE:
9886       case UNDER:
9887       case USING:
9888       case WHILE:
9889       case YES:
9890       case SHOW:
9891       case A:
9892       case UPDATE:
9893       case DOUBLE:
9894       case DEC:
9895       case PRECISION:
9896       case INT:
9897       case NUMERIC:
9898       case NCHAR:
9899       case NVARCHAR2:
9900       case STRING:
9901       case UROWID:
9902       case VARRAY:
9903       case VARYING:
9904       case BFILE:
9905       case BLOB:
9906       case CLOB:
9907       case NCLOB:
9908       case YEAR:
9909       case LOCAL:
9910       case WITH:
9911       case ZONE:
9912       case CHARACTER:
9913       case AFTER:
9914       case BEFORE:
9915       case OLD:
9916       case PARENT:
9917       case CC_IF:
9918       case CC_ERROR:
9919       case ANALYZE:
9920       case ASSOCIATE:
9921       case AUDIT:
9922       case COMPOUND:
9923       case DATABASE:
9924       case CALL:
9925       case DDL:
9926       case DISASSOCIATE:
9927       case EACH:
9928       case FOLLOWS:
9929       case LOGOFF:
9930       case LOGON:
9931       case NESTED:
9932       case NOAUDIT:
9933       case SCHEMA:
9934       case SERVERERROR:
9935       case SHUTDOWN:
9936       case STARTUP:
9937       case STATEMENT:
9938       case STATISTICS:
9939       case SUSPEND:
9940       case TRUNCATE:
9941       case WRAPPED:
9942       case LIBRARY:
9943       case NAME:
9944       case STRUCT:
9945       case CONTEXT:
9946       case PARAMETERS:
9947       case LENGTH:
9948       case TDO:
9949       case MAXLEN:
9950       case CHARSETID:
9951       case CHARSETFORM:
9952       case ACCEPT:
9953       case ACCESSIBLE:
9954       case COPY:
9955       case DEFINE:
9956       case DISCONNECT:
9957       case HOST:
9958       case PRINT:
9959       case QUIT:
9960       case REMARK:
9961       case UNDEFINE:
9962       case VARIABLE:
9963       case WHENEVER:
9964       case ATTACH:
9965       case CAST:
9966       case TREAT:
9967       case TRIM:
9968       case LEFT:
9969       case RIGHT:
9970       case BOTH:
9971       case EMPTY:
9972       case MULTISET:
9973       case SUBMULTISET:
9974       case LEADING:
9975       case TRAILING:
9976       case CHAR_CS:
9977       case NCHAR_CS:
9978       case DBTIMEZONE:
9979       case SESSIONTIMEZONE:
9980       case AUTHENTICATED:
9981       case LINK:
9982       case SHARED:
9983       case DIRECTORY:
9984       case USER:
9985       case IDENTIFIER:
9986       case UNSIGNED_NUMERIC_LITERAL:
9987       case CHARACTER_LITERAL:
9988       case STRING_LITERAL:
9989       case QUOTED_LITERAL:
9990         UnlabelledStatement();
9991         break;
9992       default:
9993         jj_la1[122] = jj_gen;
9994         jj_consume_token(-1);
9995         throw new ParseException();
9996       }
9997         jjtree.closeNodeScope(jjtn000, true);
9998         jjtc000 = false;
9999         {if (true) return jjtn000 ;}
10000     } catch (Throwable jjte000) {
10001         if (jjtc000) {
10002           jjtree.clearNodeScope(jjtn000);
10003           jjtc000 = false;
10004         } else {
10005           jjtree.popNode();
10006         }
10007         if (jjte000 instanceof RuntimeException) {
10008           {if (true) throw (RuntimeException)jjte000;}
10009         }
10010         if (jjte000 instanceof ParseException) {
10011           {if (true) throw (ParseException)jjte000;}
10012         }
10013         {if (true) throw (Error)jjte000;}
10014     } finally {
10015         if (jjtc000) {
10016           jjtree.closeNodeScope(jjtn000, true);
10017         }
10018     }
10019     throw new Error("Missing return statement in function");
10020   }
10021 
10022 /*
10023 LabelledStatement created solely to conform with PMD Java AST (for PMD DataFlow Analysis - DFA)
10024 N.B. equivalent Java AST* class is ASTLabeledStatement (single "l" rather than double "ll")
10025 */
10026   final public ASTLabelledStatement LabelledStatement() throws ParseException {
10027  /*@bgen(jjtree) LabelledStatement */
10028 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
10029 boolean jjtc000 = true;
10030 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
10031     try {
10032       label_24:
10033       while (true) {
10034         simpleNode = Label();
10035         switch (jj_nt.kind) {
10036         case 21:
10037           ;
10038           break;
10039         default:
10040           jj_la1[123] = jj_gen;
10041           break label_24;
10042         }
10043       }
10044       UnlabelledStatement();
10045         jjtree.closeNodeScope(jjtn000, true);
10046         jjtc000 = false;
10047         jjtn000.setImage( simpleNode.getImage() ) ;
10048        {if (true) return jjtn000 ;}
10049     } catch (Throwable jjte000) {
10050         if (jjtc000) {
10051           jjtree.clearNodeScope(jjtn000);
10052           jjtc000 = false;
10053         } else {
10054           jjtree.popNode();
10055         }
10056         if (jjte000 instanceof RuntimeException) {
10057           {if (true) throw (RuntimeException)jjte000;}
10058         }
10059         if (jjte000 instanceof ParseException) {
10060           {if (true) throw (ParseException)jjte000;}
10061         }
10062         {if (true) throw (Error)jjte000;}
10063     } finally {
10064         if (jjtc000) {
10065           jjtree.closeNodeScope(jjtn000, true);
10066         }
10067     }
10068     throw new Error("Missing return statement in function");
10069   }
10070 
10071   final public ASTCaseStatement CaseStatement() throws ParseException {
10072  /*@bgen(jjtree) CaseStatement */
10073   ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10074   boolean jjtc000 = true;
10075   jjtree.openNodeScope(jjtn000);
10076     try {
10077       jj_consume_token(CASE);
10078       switch (jj_nt.kind) {
10079       case 5:
10080       case 16:
10081       case 17:
10082       case REPLACE:
10083       case DEFINER:
10084       case CURRENT_USER:
10085       case LANGUAGE:
10086       case INLINE:
10087       case ADD:
10088       case AGGREGATE:
10089       case ARRAY:
10090       case AT:
10091       case ATTRIBUTE:
10092       case AUTHID:
10093       case BODY:
10094       case BULK:
10095       case BYTE:
10096       case CASCADE:
10097       case CASE:
10098       case CLOSE:
10099       case COALESCE:
10100       case COLLECT:
10101       case COLUMN:
10102       case COMMENT:
10103       case COMMIT:
10104       case CONSTRUCTOR:
10105       case CONTINUE:
10106       case CONVERT:
10107       case CURRENT:
10108       case CURSOR:
10109       case DATA:
10110       case DATE:
10111       case DAY:
10112       case DISABLE:
10113       case EDITIONABLE:
10114       case ELEMENT:
10115       case ENABLE:
10116       case ESCAPE:
10117       case EXCEPT:
10118       case EXCEPTIONS:
10119       case EXIT:
10120       case EXTERNAL:
10121       case EXTENDS:
10122       case EXTRACT:
10123       case FALSE:
10124       case FINAL:
10125       case FORCE:
10126       case FUNCTION:
10127       case GLOBAL:
10128       case HASH:
10129       case HEAP:
10130       case HOUR:
10131       case IMMEDIATE:
10132       case INDICES:
10133       case INDEXTYPE:
10134       case INDICATOR:
10135       case INSTANTIABLE:
10136       case INTERVAL:
10137       case INVALIDATE:
10138       case ISOLATION:
10139       case JAVA:
10140       case LEVEL:
10141       case LIMIT:
10142       case LOOP:
10143       case MAP:
10144       case MAX:
10145       case MEMBER:
10146       case MERGE:
10147       case MIN:
10148       case MINUTE:
10149       case MLSLABEL:
10150       case MODIFY:
10151       case MOD:
10152       case MONTH:
10153       case NATURAL:
10154       case NEW:
10155       case NEW_DOT:
10156       case NO:
10157       case NONEDITIONABLE:
10158       case NOT:
10159       case NULL:
10160       case NULLIF:
10161       case OBJECT:
10162       case OID:
10163       case OPAQUE:
10164       case OPEN:
10165       case OPERATOR:
10166       case ORGANIZATION:
10167       case OTHERS:
10168       case OVERRIDING:
10169       case PACKAGE:
10170       case PARTITION:
10171       case PRESERVE:
10172       case PRIVATE:
10173       case PROCEDURE:
10174       case RANGE:
10175       case RAW:
10176       case REAL:
10177       case RECORD:
10178       case REF:
10179       case RELEASE:
10180       case RELIES_ON:
10181       case RENAME:
10182       case RESULT:
10183       case RETURN:
10184       case RETURNING:
10185       case REVERSE:
10186       case ROLLBACK:
10187       case ROW:
10188       case ROWS:
10189       case ROWID:
10190       case ROWNUM:
10191       case SAVE:
10192       case SAVEPOINT:
10193       case SECOND:
10194       case SELECT:
10195       case SELF:
10196       case SET:
10197       case SPACE:
10198       case SQL:
10199       case SQLCODE:
10200       case SQLERRM:
10201       case STATIC:
10202       case SUBTYPE:
10203       case SUBSTITUTABLE:
10204       case SUCCESSFUL:
10205       case SYSDATE:
10206       case SYS_REFCURSOR:
10207       case TEMPORARY:
10208       case TIME:
10209       case TIMESTAMP:
10210       case TIMEZONE_REGION:
10211       case TIMEZONE_ABBR:
10212       case TIMEZONE_MINUTE:
10213       case TIMEZONE_HOUR:
10214       case TRANSACTION:
10215       case TRUE:
10216       case TYPE:
10217       case UNDER:
10218       case USING:
10219       case YES:
10220       case SHOW:
10221       case A:
10222       case DOUBLE:
10223       case DEC:
10224       case PRECISION:
10225       case INT:
10226       case NUMERIC:
10227       case NCHAR:
10228       case NVARCHAR2:
10229       case STRING:
10230       case UROWID:
10231       case VARRAY:
10232       case VARYING:
10233       case BFILE:
10234       case BLOB:
10235       case CLOB:
10236       case NCLOB:
10237       case YEAR:
10238       case LOCAL:
10239       case WITH:
10240       case ZONE:
10241       case CHARACTER:
10242       case AFTER:
10243       case BEFORE:
10244       case OLD:
10245       case PARENT:
10246       case CC_IF:
10247       case ANALYZE:
10248       case ASSOCIATE:
10249       case AUDIT:
10250       case COMPOUND:
10251       case DATABASE:
10252       case CALL:
10253       case DDL:
10254       case DISASSOCIATE:
10255       case EACH:
10256       case FOLLOWS:
10257       case LOGOFF:
10258       case LOGON:
10259       case NESTED:
10260       case NOAUDIT:
10261       case SCHEMA:
10262       case SERVERERROR:
10263       case SHUTDOWN:
10264       case STARTUP:
10265       case STATEMENT:
10266       case STATISTICS:
10267       case SUSPEND:
10268       case TRUNCATE:
10269       case WRAPPED:
10270       case LIBRARY:
10271       case NAME:
10272       case STRUCT:
10273       case CONTEXT:
10274       case PARAMETERS:
10275       case LENGTH:
10276       case TDO:
10277       case MAXLEN:
10278       case CHARSETID:
10279       case CHARSETFORM:
10280       case ACCEPT:
10281       case ACCESSIBLE:
10282       case COPY:
10283       case DEFINE:
10284       case DISCONNECT:
10285       case HOST:
10286       case PRINT:
10287       case QUIT:
10288       case REMARK:
10289       case UNDEFINE:
10290       case VARIABLE:
10291       case WHENEVER:
10292       case ATTACH:
10293       case CAST:
10294       case TREAT:
10295       case TRIM:
10296       case LEFT:
10297       case RIGHT:
10298       case BOTH:
10299       case EMPTY:
10300       case MULTISET:
10301       case SUBMULTISET:
10302       case LEADING:
10303       case TRAILING:
10304       case CHAR_CS:
10305       case NCHAR_CS:
10306       case DBTIMEZONE:
10307       case SESSIONTIMEZONE:
10308       case AUTHENTICATED:
10309       case LINK:
10310       case SHARED:
10311       case DIRECTORY:
10312       case USER:
10313       case IDENTIFIER:
10314       case UNSIGNED_NUMERIC_LITERAL:
10315       case CHARACTER_LITERAL:
10316       case STRING_LITERAL:
10317       case QUOTED_LITERAL:
10318         Expression();
10319         break;
10320       default:
10321         jj_la1[124] = jj_gen;
10322         ;
10323       }
10324       label_25:
10325       while (true) {
10326         switch (jj_nt.kind) {
10327         case WHEN:
10328           ;
10329           break;
10330         default:
10331           jj_la1[125] = jj_gen;
10332           break label_25;
10333         }
10334         CaseWhenClause();
10335       }
10336       switch (jj_nt.kind) {
10337       case ELSE:
10338         ElseClause();
10339         break;
10340       default:
10341         jj_la1[126] = jj_gen;
10342         ;
10343       }
10344       jj_consume_token(END);
10345       jj_consume_token(CASE);
10346       switch (jj_nt.kind) {
10347       case IDENTIFIER:
10348         jj_consume_token(IDENTIFIER);
10349         break;
10350       default:
10351         jj_la1[127] = jj_gen;
10352         ;
10353       }
10354         jjtree.closeNodeScope(jjtn000, true);
10355         jjtc000 = false;
10356         {if (true) return jjtn000 ;}
10357     } catch (Throwable jjte000) {
10358          if (jjtc000) {
10359            jjtree.clearNodeScope(jjtn000);
10360            jjtc000 = false;
10361          } else {
10362            jjtree.popNode();
10363          }
10364          if (jjte000 instanceof RuntimeException) {
10365            {if (true) throw (RuntimeException)jjte000;}
10366          }
10367          if (jjte000 instanceof ParseException) {
10368            {if (true) throw (ParseException)jjte000;}
10369          }
10370          {if (true) throw (Error)jjte000;}
10371     } finally {
10372          if (jjtc000) {
10373            jjtree.closeNodeScope(jjtn000, true);
10374          }
10375     }
10376     throw new Error("Missing return statement in function");
10377   }
10378 
10379   final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10380  /*@bgen(jjtree) CaseWhenClause */
10381   ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10382   boolean jjtc000 = true;
10383   jjtree.openNodeScope(jjtn000);
10384     try {
10385       jj_consume_token(WHEN);
10386       Expression();
10387       jj_consume_token(THEN);
10388       label_26:
10389       while (true) {
10390         Statement();
10391         switch (jj_nt.kind) {
10392         case 5:
10393         case 16:
10394         case 17:
10395         case 21:
10396         case REPLACE:
10397         case DEFINER:
10398         case CURRENT_USER:
10399         case LANGUAGE:
10400         case INLINE:
10401         case ADD:
10402         case AGGREGATE:
10403         case ARRAY:
10404         case AT:
10405         case ATTRIBUTE:
10406         case AUTHID:
10407         case BEGIN:
10408         case BODY:
10409         case BULK:
10410         case BYTE:
10411         case CASCADE:
10412         case CASE:
10413         case CLOSE:
10414         case COALESCE:
10415         case COLLECT:
10416         case COLUMN:
10417         case COMMENT:
10418         case COMMIT:
10419         case CONSTRUCTOR:
10420         case CONTINUE:
10421         case CONVERT:
10422         case CURRENT:
10423         case CURSOR:
10424         case DATA:
10425         case DATE:
10426         case DAY:
10427         case DECLARE:
10428         case DELETE:
10429         case DISABLE:
10430         case EDITIONABLE:
10431         case ELEMENT:
10432         case ENABLE:
10433         case ESCAPE:
10434         case EXCEPT:
10435         case EXCEPTIONS:
10436         case EXECUTE:
10437         case EXIT:
10438         case EXTERNAL:
10439         case EXTENDS:
10440         case EXTRACT:
10441         case FALSE:
10442         case FETCH:
10443         case FINAL:
10444         case FOR:
10445         case FORALL:
10446         case FORCE:
10447         case FUNCTION:
10448         case GLOBAL:
10449         case GOTO:
10450         case HASH:
10451         case HEAP:
10452         case HOUR:
10453         case IF:
10454         case IMMEDIATE:
10455         case INDICES:
10456         case INDEXTYPE:
10457         case INDICATOR:
10458         case INSERT:
10459         case INSTANTIABLE:
10460         case INTERVAL:
10461         case INVALIDATE:
10462         case ISOLATION:
10463         case JAVA:
10464         case LEVEL:
10465         case LIMIT:
10466         case LOCK:
10467         case LOOP:
10468         case MAP:
10469         case MAX:
10470         case MEMBER:
10471         case MERGE:
10472         case MIN:
10473         case MINUTE:
10474         case MLSLABEL:
10475         case MODIFY:
10476         case MOD:
10477         case MONTH:
10478         case NATURAL:
10479         case NEW:
10480         case NEW_DOT:
10481         case NO:
10482         case NONEDITIONABLE:
10483         case NOT:
10484         case NULL:
10485         case NULLIF:
10486         case OBJECT:
10487         case OID:
10488         case OPAQUE:
10489         case OPEN:
10490         case OPERATOR:
10491         case ORGANIZATION:
10492         case OTHERS:
10493         case OVERRIDING:
10494         case PACKAGE:
10495         case PARTITION:
10496         case PIPE:
10497         case PRAGMA:
10498         case PRESERVE:
10499         case PRIVATE:
10500         case PROCEDURE:
10501         case RAISE:
10502         case RANGE:
10503         case RAW:
10504         case REAL:
10505         case RECORD:
10506         case REF:
10507         case RELEASE:
10508         case RELIES_ON:
10509         case RENAME:
10510         case RESULT:
10511         case RETURN:
10512         case RETURNING:
10513         case REVERSE:
10514         case ROLLBACK:
10515         case ROW:
10516         case ROWS:
10517         case ROWID:
10518         case ROWNUM:
10519         case SAVE:
10520         case SAVEPOINT:
10521         case SECOND:
10522         case SELECT:
10523         case SELF:
10524         case SET:
10525         case SPACE:
10526         case SQL:
10527         case SQLCODE:
10528         case SQLERRM:
10529         case STATIC:
10530         case SUBTYPE:
10531         case SUBSTITUTABLE:
10532         case SUCCESSFUL:
10533         case SYSDATE:
10534         case SYS_REFCURSOR:
10535         case TEMPORARY:
10536         case TIME:
10537         case TIMESTAMP:
10538         case TIMEZONE_REGION:
10539         case TIMEZONE_ABBR:
10540         case TIMEZONE_MINUTE:
10541         case TIMEZONE_HOUR:
10542         case TRANSACTION:
10543         case TRUE:
10544         case TYPE:
10545         case UNDER:
10546         case USING:
10547         case WHILE:
10548         case YES:
10549         case SHOW:
10550         case A:
10551         case UPDATE:
10552         case DOUBLE:
10553         case DEC:
10554         case PRECISION:
10555         case INT:
10556         case NUMERIC:
10557         case NCHAR:
10558         case NVARCHAR2:
10559         case STRING:
10560         case UROWID:
10561         case VARRAY:
10562         case VARYING:
10563         case BFILE:
10564         case BLOB:
10565         case CLOB:
10566         case NCLOB:
10567         case YEAR:
10568         case LOCAL:
10569         case WITH:
10570         case ZONE:
10571         case CHARACTER:
10572         case AFTER:
10573         case BEFORE:
10574         case OLD:
10575         case PARENT:
10576         case CC_IF:
10577         case CC_ERROR:
10578         case ANALYZE:
10579         case ASSOCIATE:
10580         case AUDIT:
10581         case COMPOUND:
10582         case DATABASE:
10583         case CALL:
10584         case DDL:
10585         case DISASSOCIATE:
10586         case EACH:
10587         case FOLLOWS:
10588         case LOGOFF:
10589         case LOGON:
10590         case NESTED:
10591         case NOAUDIT:
10592         case SCHEMA:
10593         case SERVERERROR:
10594         case SHUTDOWN:
10595         case STARTUP:
10596         case STATEMENT:
10597         case STATISTICS:
10598         case SUSPEND:
10599         case TRUNCATE:
10600         case WRAPPED:
10601         case LIBRARY:
10602         case NAME:
10603         case STRUCT:
10604         case CONTEXT:
10605         case PARAMETERS:
10606         case LENGTH:
10607         case TDO:
10608         case MAXLEN:
10609         case CHARSETID:
10610         case CHARSETFORM:
10611         case ACCEPT:
10612         case ACCESSIBLE:
10613         case COPY:
10614         case DEFINE:
10615         case DISCONNECT:
10616         case HOST:
10617         case PRINT:
10618         case QUIT:
10619         case REMARK:
10620         case UNDEFINE:
10621         case VARIABLE:
10622         case WHENEVER:
10623         case ATTACH:
10624         case CAST:
10625         case TREAT:
10626         case TRIM:
10627         case LEFT:
10628         case RIGHT:
10629         case BOTH:
10630         case EMPTY:
10631         case MULTISET:
10632         case SUBMULTISET:
10633         case LEADING:
10634         case TRAILING:
10635         case CHAR_CS:
10636         case NCHAR_CS:
10637         case DBTIMEZONE:
10638         case SESSIONTIMEZONE:
10639         case AUTHENTICATED:
10640         case LINK:
10641         case SHARED:
10642         case DIRECTORY:
10643         case USER:
10644         case IDENTIFIER:
10645         case UNSIGNED_NUMERIC_LITERAL:
10646         case CHARACTER_LITERAL:
10647         case STRING_LITERAL:
10648         case QUOTED_LITERAL:
10649           ;
10650           break;
10651         default:
10652           jj_la1[128] = jj_gen;
10653           break label_26;
10654         }
10655       }
10656         jjtree.closeNodeScope(jjtn000, true);
10657         jjtc000 = false;
10658         {if (true) return jjtn000 ;}
10659     } catch (Throwable jjte000) {
10660           if (jjtc000) {
10661             jjtree.clearNodeScope(jjtn000);
10662             jjtc000 = false;
10663           } else {
10664             jjtree.popNode();
10665           }
10666           if (jjte000 instanceof RuntimeException) {
10667             {if (true) throw (RuntimeException)jjte000;}
10668           }
10669           if (jjte000 instanceof ParseException) {
10670             {if (true) throw (ParseException)jjte000;}
10671           }
10672           {if (true) throw (Error)jjte000;}
10673     } finally {
10674           if (jjtc000) {
10675             jjtree.closeNodeScope(jjtn000, true);
10676           }
10677     }
10678     throw new Error("Missing return statement in function");
10679   }
10680 
10681   final public ASTElseClause ElseClause() throws ParseException {
10682  /*@bgen(jjtree) ElseClause */
10683   ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10684   boolean jjtc000 = true;
10685   jjtree.openNodeScope(jjtn000);
10686     try {
10687       jj_consume_token(ELSE);
10688       label_27:
10689       while (true) {
10690         Statement();
10691         switch (jj_nt.kind) {
10692         case 5:
10693         case 16:
10694         case 17:
10695         case 21:
10696         case REPLACE:
10697         case DEFINER:
10698         case CURRENT_USER:
10699         case LANGUAGE:
10700         case INLINE:
10701         case ADD:
10702         case AGGREGATE:
10703         case ARRAY:
10704         case AT:
10705         case ATTRIBUTE:
10706         case AUTHID:
10707         case BEGIN:
10708         case BODY:
10709         case BULK:
10710         case BYTE:
10711         case CASCADE:
10712         case CASE:
10713         case CLOSE:
10714         case COALESCE:
10715         case COLLECT:
10716         case COLUMN:
10717         case COMMENT:
10718         case COMMIT:
10719         case CONSTRUCTOR:
10720         case CONTINUE:
10721         case CONVERT:
10722         case CURRENT:
10723         case CURSOR:
10724         case DATA:
10725         case DATE:
10726         case DAY:
10727         case DECLARE:
10728         case DELETE:
10729         case DISABLE:
10730         case EDITIONABLE:
10731         case ELEMENT:
10732         case ENABLE:
10733         case ESCAPE:
10734         case EXCEPT:
10735         case EXCEPTIONS:
10736         case EXECUTE:
10737         case EXIT:
10738         case EXTERNAL:
10739         case EXTENDS:
10740         case EXTRACT:
10741         case FALSE:
10742         case FETCH:
10743         case FINAL:
10744         case FOR:
10745         case FORALL:
10746         case FORCE:
10747         case FUNCTION:
10748         case GLOBAL:
10749         case GOTO:
10750         case HASH:
10751         case HEAP:
10752         case HOUR:
10753         case IF:
10754         case IMMEDIATE:
10755         case INDICES:
10756         case INDEXTYPE:
10757         case INDICATOR:
10758         case INSERT:
10759         case INSTANTIABLE:
10760         case INTERVAL:
10761         case INVALIDATE:
10762         case ISOLATION:
10763         case JAVA:
10764         case LEVEL:
10765         case LIMIT:
10766         case LOCK:
10767         case LOOP:
10768         case MAP:
10769         case MAX:
10770         case MEMBER:
10771         case MERGE:
10772         case MIN:
10773         case MINUTE:
10774         case MLSLABEL:
10775         case MODIFY:
10776         case MOD:
10777         case MONTH:
10778         case NATURAL:
10779         case NEW:
10780         case NEW_DOT:
10781         case NO:
10782         case NONEDITIONABLE:
10783         case NOT:
10784         case NULL:
10785         case NULLIF:
10786         case OBJECT:
10787         case OID:
10788         case OPAQUE:
10789         case OPEN:
10790         case OPERATOR:
10791         case ORGANIZATION:
10792         case OTHERS:
10793         case OVERRIDING:
10794         case PACKAGE:
10795         case PARTITION:
10796         case PIPE:
10797         case PRAGMA:
10798         case PRESERVE:
10799         case PRIVATE:
10800         case PROCEDURE:
10801         case RAISE:
10802         case RANGE:
10803         case RAW:
10804         case REAL:
10805         case RECORD:
10806         case REF:
10807         case RELEASE:
10808         case RELIES_ON:
10809         case RENAME:
10810         case RESULT:
10811         case RETURN:
10812         case RETURNING:
10813         case REVERSE:
10814         case ROLLBACK:
10815         case ROW:
10816         case ROWS:
10817         case ROWID:
10818         case ROWNUM:
10819         case SAVE:
10820         case SAVEPOINT:
10821         case SECOND:
10822         case SELECT:
10823         case SELF:
10824         case SET:
10825         case SPACE:
10826         case SQL:
10827         case SQLCODE:
10828         case SQLERRM:
10829         case STATIC:
10830         case SUBTYPE:
10831         case SUBSTITUTABLE:
10832         case SUCCESSFUL:
10833         case SYSDATE:
10834         case SYS_REFCURSOR:
10835         case TEMPORARY:
10836         case TIME:
10837         case TIMESTAMP:
10838         case TIMEZONE_REGION:
10839         case TIMEZONE_ABBR:
10840         case TIMEZONE_MINUTE:
10841         case TIMEZONE_HOUR:
10842         case TRANSACTION:
10843         case TRUE:
10844         case TYPE:
10845         case UNDER:
10846         case USING:
10847         case WHILE:
10848         case YES:
10849         case SHOW:
10850         case A:
10851         case UPDATE:
10852         case DOUBLE:
10853         case DEC:
10854         case PRECISION:
10855         case INT:
10856         case NUMERIC:
10857         case NCHAR:
10858         case NVARCHAR2:
10859         case STRING:
10860         case UROWID:
10861         case VARRAY:
10862         case VARYING:
10863         case BFILE:
10864         case BLOB:
10865         case CLOB:
10866         case NCLOB:
10867         case YEAR:
10868         case LOCAL:
10869         case WITH:
10870         case ZONE:
10871         case CHARACTER:
10872         case AFTER:
10873         case BEFORE:
10874         case OLD:
10875         case PARENT:
10876         case CC_IF:
10877         case CC_ERROR:
10878         case ANALYZE:
10879         case ASSOCIATE:
10880         case AUDIT:
10881         case COMPOUND:
10882         case DATABASE:
10883         case CALL:
10884         case DDL:
10885         case DISASSOCIATE:
10886         case EACH:
10887         case FOLLOWS:
10888         case LOGOFF:
10889         case LOGON:
10890         case NESTED:
10891         case NOAUDIT:
10892         case SCHEMA:
10893         case SERVERERROR:
10894         case SHUTDOWN:
10895         case STARTUP:
10896         case STATEMENT:
10897         case STATISTICS:
10898         case SUSPEND:
10899         case TRUNCATE:
10900         case WRAPPED:
10901         case LIBRARY:
10902         case NAME:
10903         case STRUCT:
10904         case CONTEXT:
10905         case PARAMETERS:
10906         case LENGTH:
10907         case TDO:
10908         case MAXLEN:
10909         case CHARSETID:
10910         case CHARSETFORM:
10911         case ACCEPT:
10912         case ACCESSIBLE:
10913         case COPY:
10914         case DEFINE:
10915         case DISCONNECT:
10916         case HOST:
10917         case PRINT:
10918         case QUIT:
10919         case REMARK:
10920         case UNDEFINE:
10921         case VARIABLE:
10922         case WHENEVER:
10923         case ATTACH:
10924         case CAST:
10925         case TREAT:
10926         case TRIM:
10927         case LEFT:
10928         case RIGHT:
10929         case BOTH:
10930         case EMPTY:
10931         case MULTISET:
10932         case SUBMULTISET:
10933         case LEADING:
10934         case TRAILING:
10935         case CHAR_CS:
10936         case NCHAR_CS:
10937         case DBTIMEZONE:
10938         case SESSIONTIMEZONE:
10939         case AUTHENTICATED:
10940         case LINK:
10941         case SHARED:
10942         case DIRECTORY:
10943         case USER:
10944         case IDENTIFIER:
10945         case UNSIGNED_NUMERIC_LITERAL:
10946         case CHARACTER_LITERAL:
10947         case STRING_LITERAL:
10948         case QUOTED_LITERAL:
10949           ;
10950           break;
10951         default:
10952           jj_la1[129] = jj_gen;
10953           break label_27;
10954         }
10955       }
10956         jjtree.closeNodeScope(jjtn000, true);
10957         jjtc000 = false;
10958         {if (true) return jjtn000 ;}
10959     } catch (Throwable jjte000) {
10960           if (jjtc000) {
10961             jjtree.clearNodeScope(jjtn000);
10962             jjtc000 = false;
10963           } else {
10964             jjtree.popNode();
10965           }
10966           if (jjte000 instanceof RuntimeException) {
10967             {if (true) throw (RuntimeException)jjte000;}
10968           }
10969           if (jjte000 instanceof ParseException) {
10970             {if (true) throw (ParseException)jjte000;}
10971           }
10972           {if (true) throw (Error)jjte000;}
10973     } finally {
10974           if (jjtc000) {
10975             jjtree.closeNodeScope(jjtn000, true);
10976           }
10977     }
10978     throw new Error("Missing return statement in function");
10979   }
10980 
10981   final public ASTElsifClause ElsifClause() throws ParseException {
10982  /*@bgen(jjtree) ElsifClause */
10983   ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10984   boolean jjtc000 = true;
10985   jjtree.openNodeScope(jjtn000);
10986     try {
10987       jj_consume_token(ELSIF);
10988       Expression();
10989       jj_consume_token(THEN);
10990       label_28:
10991       while (true) {
10992         Statement();
10993         switch (jj_nt.kind) {
10994         case 5:
10995         case 16:
10996         case 17:
10997         case 21:
10998         case REPLACE:
10999         case DEFINER:
11000         case CURRENT_USER:
11001         case LANGUAGE:
11002         case INLINE:
11003         case ADD:
11004         case AGGREGATE:
11005         case ARRAY:
11006         case AT:
11007         case ATTRIBUTE:
11008         case AUTHID:
11009         case BEGIN:
11010         case BODY:
11011         case BULK:
11012         case BYTE:
11013         case CASCADE:
11014         case CASE:
11015         case CLOSE:
11016         case COALESCE:
11017         case COLLECT:
11018         case COLUMN:
11019         case COMMENT:
11020         case COMMIT:
11021         case CONSTRUCTOR:
11022         case CONTINUE:
11023         case CONVERT:
11024         case CURRENT:
11025         case CURSOR:
11026         case DATA:
11027         case DATE:
11028         case DAY:
11029         case DECLARE:
11030         case DELETE:
11031         case DISABLE:
11032         case EDITIONABLE:
11033         case ELEMENT:
11034         case ENABLE:
11035         case ESCAPE:
11036         case EXCEPT:
11037         case EXCEPTIONS:
11038         case EXECUTE:
11039         case EXIT:
11040         case EXTERNAL:
11041         case EXTENDS:
11042         case EXTRACT:
11043         case FALSE:
11044         case FETCH:
11045         case FINAL:
11046         case FOR:
11047         case FORALL:
11048         case FORCE:
11049         case FUNCTION:
11050         case GLOBAL:
11051         case GOTO:
11052         case HASH:
11053         case HEAP:
11054         case HOUR:
11055         case IF:
11056         case IMMEDIATE:
11057         case INDICES:
11058         case INDEXTYPE:
11059         case INDICATOR:
11060         case INSERT:
11061         case INSTANTIABLE:
11062         case INTERVAL:
11063         case INVALIDATE:
11064         case ISOLATION:
11065         case JAVA:
11066         case LEVEL:
11067         case LIMIT:
11068         case LOCK:
11069         case LOOP:
11070         case MAP:
11071         case MAX:
11072         case MEMBER:
11073         case MERGE:
11074         case MIN:
11075         case MINUTE:
11076         case MLSLABEL:
11077         case MODIFY:
11078         case MOD:
11079         case MONTH:
11080         case NATURAL:
11081         case NEW:
11082         case NEW_DOT:
11083         case NO:
11084         case NONEDITIONABLE:
11085         case NOT:
11086         case NULL:
11087         case NULLIF:
11088         case OBJECT:
11089         case OID:
11090         case OPAQUE:
11091         case OPEN:
11092         case OPERATOR:
11093         case ORGANIZATION:
11094         case OTHERS:
11095         case OVERRIDING:
11096         case PACKAGE:
11097         case PARTITION:
11098         case PIPE:
11099         case PRAGMA:
11100         case PRESERVE:
11101         case PRIVATE:
11102         case PROCEDURE:
11103         case RAISE:
11104         case RANGE:
11105         case RAW:
11106         case REAL:
11107         case RECORD:
11108         case REF:
11109         case RELEASE:
11110         case RELIES_ON:
11111         case RENAME:
11112         case RESULT:
11113         case RETURN:
11114         case RETURNING:
11115         case REVERSE:
11116         case ROLLBACK:
11117         case ROW:
11118         case ROWS:
11119         case ROWID:
11120         case ROWNUM:
11121         case SAVE:
11122         case SAVEPOINT:
11123         case SECOND:
11124         case SELECT:
11125         case SELF:
11126         case SET:
11127         case SPACE:
11128         case SQL:
11129         case SQLCODE:
11130         case SQLERRM:
11131         case STATIC:
11132         case SUBTYPE:
11133         case SUBSTITUTABLE:
11134         case SUCCESSFUL:
11135         case SYSDATE:
11136         case SYS_REFCURSOR:
11137         case TEMPORARY:
11138         case TIME:
11139         case TIMESTAMP:
11140         case TIMEZONE_REGION:
11141         case TIMEZONE_ABBR:
11142         case TIMEZONE_MINUTE:
11143         case TIMEZONE_HOUR:
11144         case TRANSACTION:
11145         case TRUE:
11146         case TYPE:
11147         case UNDER:
11148         case USING:
11149         case WHILE:
11150         case YES:
11151         case SHOW:
11152         case A:
11153         case UPDATE:
11154         case DOUBLE:
11155         case DEC:
11156         case PRECISION:
11157         case INT:
11158         case NUMERIC:
11159         case NCHAR:
11160         case NVARCHAR2:
11161         case STRING:
11162         case UROWID:
11163         case VARRAY:
11164         case VARYING:
11165         case BFILE:
11166         case BLOB:
11167         case CLOB:
11168         case NCLOB:
11169         case YEAR:
11170         case LOCAL:
11171         case WITH:
11172         case ZONE:
11173         case CHARACTER:
11174         case AFTER:
11175         case BEFORE:
11176         case OLD:
11177         case PARENT:
11178         case CC_IF:
11179         case CC_ERROR:
11180         case ANALYZE:
11181         case ASSOCIATE:
11182         case AUDIT:
11183         case COMPOUND:
11184         case DATABASE:
11185         case CALL:
11186         case DDL:
11187         case DISASSOCIATE:
11188         case EACH:
11189         case FOLLOWS:
11190         case LOGOFF:
11191         case LOGON:
11192         case NESTED:
11193         case NOAUDIT:
11194         case SCHEMA:
11195         case SERVERERROR:
11196         case SHUTDOWN:
11197         case STARTUP:
11198         case STATEMENT:
11199         case STATISTICS:
11200         case SUSPEND:
11201         case TRUNCATE:
11202         case WRAPPED:
11203         case LIBRARY:
11204         case NAME:
11205         case STRUCT:
11206         case CONTEXT:
11207         case PARAMETERS:
11208         case LENGTH:
11209         case TDO:
11210         case MAXLEN:
11211         case CHARSETID:
11212         case CHARSETFORM:
11213         case ACCEPT:
11214         case ACCESSIBLE:
11215         case COPY:
11216         case DEFINE:
11217         case DISCONNECT:
11218         case HOST:
11219         case PRINT:
11220         case QUIT:
11221         case REMARK:
11222         case UNDEFINE:
11223         case VARIABLE:
11224         case WHENEVER:
11225         case ATTACH:
11226         case CAST:
11227         case TREAT:
11228         case TRIM:
11229         case LEFT:
11230         case RIGHT:
11231         case BOTH:
11232         case EMPTY:
11233         case MULTISET:
11234         case SUBMULTISET:
11235         case LEADING:
11236         case TRAILING:
11237         case CHAR_CS:
11238         case NCHAR_CS:
11239         case DBTIMEZONE:
11240         case SESSIONTIMEZONE:
11241         case AUTHENTICATED:
11242         case LINK:
11243         case SHARED:
11244         case DIRECTORY:
11245         case USER:
11246         case IDENTIFIER:
11247         case UNSIGNED_NUMERIC_LITERAL:
11248         case CHARACTER_LITERAL:
11249         case STRING_LITERAL:
11250         case QUOTED_LITERAL:
11251           ;
11252           break;
11253         default:
11254           jj_la1[130] = jj_gen;
11255           break label_28;
11256         }
11257       }
11258         jjtree.closeNodeScope(jjtn000, true);
11259         jjtc000 = false;
11260         {if (true) return jjtn000 ;}
11261     } catch (Throwable jjte000) {
11262         if (jjtc000) {
11263           jjtree.clearNodeScope(jjtn000);
11264           jjtc000 = false;
11265         } else {
11266           jjtree.popNode();
11267         }
11268         if (jjte000 instanceof RuntimeException) {
11269           {if (true) throw (RuntimeException)jjte000;}
11270         }
11271         if (jjte000 instanceof ParseException) {
11272           {if (true) throw (ParseException)jjte000;}
11273         }
11274         {if (true) throw (Error)jjte000;}
11275     } finally {
11276         if (jjtc000) {
11277           jjtree.closeNodeScope(jjtn000, true);
11278         }
11279     }
11280     throw new Error("Missing return statement in function");
11281   }
11282 
11283   final public ASTLoopStatement LoopStatement() throws ParseException {
11284  /*@bgen(jjtree) LoopStatement */
11285   ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11286   boolean jjtc000 = true;
11287   jjtree.openNodeScope(jjtn000);
11288     try {
11289       jj_consume_token(LOOP);
11290       label_29:
11291       while (true) {
11292         Statement();
11293         switch (jj_nt.kind) {
11294         case 5:
11295         case 16:
11296         case 17:
11297         case 21:
11298         case REPLACE:
11299         case DEFINER:
11300         case CURRENT_USER:
11301         case LANGUAGE:
11302         case INLINE:
11303         case ADD:
11304         case AGGREGATE:
11305         case ARRAY:
11306         case AT:
11307         case ATTRIBUTE:
11308         case AUTHID:
11309         case BEGIN:
11310         case BODY:
11311         case BULK:
11312         case BYTE:
11313         case CASCADE:
11314         case CASE:
11315         case CLOSE:
11316         case COALESCE:
11317         case COLLECT:
11318         case COLUMN:
11319         case COMMENT:
11320         case COMMIT:
11321         case CONSTRUCTOR:
11322         case CONTINUE:
11323         case CONVERT:
11324         case CURRENT:
11325         case CURSOR:
11326         case DATA:
11327         case DATE:
11328         case DAY:
11329         case DECLARE:
11330         case DELETE:
11331         case DISABLE:
11332         case EDITIONABLE:
11333         case ELEMENT:
11334         case ENABLE:
11335         case ESCAPE:
11336         case EXCEPT:
11337         case EXCEPTIONS:
11338         case EXECUTE:
11339         case EXIT:
11340         case EXTERNAL:
11341         case EXTENDS:
11342         case EXTRACT:
11343         case FALSE:
11344         case FETCH:
11345         case FINAL:
11346         case FOR:
11347         case FORALL:
11348         case FORCE:
11349         case FUNCTION:
11350         case GLOBAL:
11351         case GOTO:
11352         case HASH:
11353         case HEAP:
11354         case HOUR:
11355         case IF:
11356         case IMMEDIATE:
11357         case INDICES:
11358         case INDEXTYPE:
11359         case INDICATOR:
11360         case INSERT:
11361         case INSTANTIABLE:
11362         case INTERVAL:
11363         case INVALIDATE:
11364         case ISOLATION:
11365         case JAVA:
11366         case LEVEL:
11367         case LIMIT:
11368         case LOCK:
11369         case LOOP:
11370         case MAP:
11371         case MAX:
11372         case MEMBER:
11373         case MERGE:
11374         case MIN:
11375         case MINUTE:
11376         case MLSLABEL:
11377         case MODIFY:
11378         case MOD:
11379         case MONTH:
11380         case NATURAL:
11381         case NEW:
11382         case NEW_DOT:
11383         case NO:
11384         case NONEDITIONABLE:
11385         case NOT:
11386         case NULL:
11387         case NULLIF:
11388         case OBJECT:
11389         case OID:
11390         case OPAQUE:
11391         case OPEN:
11392         case OPERATOR:
11393         case ORGANIZATION:
11394         case OTHERS:
11395         case OVERRIDING:
11396         case PACKAGE:
11397         case PARTITION:
11398         case PIPE:
11399         case PRAGMA:
11400         case PRESERVE:
11401         case PRIVATE:
11402         case PROCEDURE:
11403         case RAISE:
11404         case RANGE:
11405         case RAW:
11406         case REAL:
11407         case RECORD:
11408         case REF:
11409         case RELEASE:
11410         case RELIES_ON:
11411         case RENAME:
11412         case RESULT:
11413         case RETURN:
11414         case RETURNING:
11415         case REVERSE:
11416         case ROLLBACK:
11417         case ROW:
11418         case ROWS:
11419         case ROWID:
11420         case ROWNUM:
11421         case SAVE:
11422         case SAVEPOINT:
11423         case SECOND:
11424         case SELECT:
11425         case SELF:
11426         case SET:
11427         case SPACE:
11428         case SQL:
11429         case SQLCODE:
11430         case SQLERRM:
11431         case STATIC:
11432         case SUBTYPE:
11433         case SUBSTITUTABLE:
11434         case SUCCESSFUL:
11435         case SYSDATE:
11436         case SYS_REFCURSOR:
11437         case TEMPORARY:
11438         case TIME:
11439         case TIMESTAMP:
11440         case TIMEZONE_REGION:
11441         case TIMEZONE_ABBR:
11442         case TIMEZONE_MINUTE:
11443         case TIMEZONE_HOUR:
11444         case TRANSACTION:
11445         case TRUE:
11446         case TYPE:
11447         case UNDER:
11448         case USING:
11449         case WHILE:
11450         case YES:
11451         case SHOW:
11452         case A:
11453         case UPDATE:
11454         case DOUBLE:
11455         case DEC:
11456         case PRECISION:
11457         case INT:
11458         case NUMERIC:
11459         case NCHAR:
11460         case NVARCHAR2:
11461         case STRING:
11462         case UROWID:
11463         case VARRAY:
11464         case VARYING:
11465         case BFILE:
11466         case BLOB:
11467         case CLOB:
11468         case NCLOB:
11469         case YEAR:
11470         case LOCAL:
11471         case WITH:
11472         case ZONE:
11473         case CHARACTER:
11474         case AFTER:
11475         case BEFORE:
11476         case OLD:
11477         case PARENT:
11478         case CC_IF:
11479         case CC_ERROR:
11480         case ANALYZE:
11481         case ASSOCIATE:
11482         case AUDIT:
11483         case COMPOUND:
11484         case DATABASE:
11485         case CALL:
11486         case DDL:
11487         case DISASSOCIATE:
11488         case EACH:
11489         case FOLLOWS:
11490         case LOGOFF:
11491         case LOGON:
11492         case NESTED:
11493         case NOAUDIT:
11494         case SCHEMA:
11495         case SERVERERROR:
11496         case SHUTDOWN:
11497         case STARTUP:
11498         case STATEMENT:
11499         case STATISTICS:
11500         case SUSPEND:
11501         case TRUNCATE:
11502         case WRAPPED:
11503         case LIBRARY:
11504         case NAME:
11505         case STRUCT:
11506         case CONTEXT:
11507         case PARAMETERS:
11508         case LENGTH:
11509         case TDO:
11510         case MAXLEN:
11511         case CHARSETID:
11512         case CHARSETFORM:
11513         case ACCEPT:
11514         case ACCESSIBLE:
11515         case COPY:
11516         case DEFINE:
11517         case DISCONNECT:
11518         case HOST:
11519         case PRINT:
11520         case QUIT:
11521         case REMARK:
11522         case UNDEFINE:
11523         case VARIABLE:
11524         case WHENEVER:
11525         case ATTACH:
11526         case CAST:
11527         case TREAT:
11528         case TRIM:
11529         case LEFT:
11530         case RIGHT:
11531         case BOTH:
11532         case EMPTY:
11533         case MULTISET:
11534         case SUBMULTISET:
11535         case LEADING:
11536         case TRAILING:
11537         case CHAR_CS:
11538         case NCHAR_CS:
11539         case DBTIMEZONE:
11540         case SESSIONTIMEZONE:
11541         case AUTHENTICATED:
11542         case LINK:
11543         case SHARED:
11544         case DIRECTORY:
11545         case USER:
11546         case IDENTIFIER:
11547         case UNSIGNED_NUMERIC_LITERAL:
11548         case CHARACTER_LITERAL:
11549         case STRING_LITERAL:
11550         case QUOTED_LITERAL:
11551           ;
11552           break;
11553         default:
11554           jj_la1[131] = jj_gen;
11555           break label_29;
11556         }
11557       }
11558       jj_consume_token(END);
11559       jj_consume_token(LOOP);
11560       switch (jj_nt.kind) {
11561       case IDENTIFIER:
11562         jj_consume_token(IDENTIFIER);
11563         break;
11564       default:
11565         jj_la1[132] = jj_gen;
11566         ;
11567       }
11568         jjtree.closeNodeScope(jjtn000, true);
11569         jjtc000 = false;
11570         {if (true) return jjtn000 ;}
11571     } catch (Throwable jjte000) {
11572          if (jjtc000) {
11573            jjtree.clearNodeScope(jjtn000);
11574            jjtc000 = false;
11575          } else {
11576            jjtree.popNode();
11577          }
11578          if (jjte000 instanceof RuntimeException) {
11579            {if (true) throw (RuntimeException)jjte000;}
11580          }
11581          if (jjte000 instanceof ParseException) {
11582            {if (true) throw (ParseException)jjte000;}
11583          }
11584          {if (true) throw (Error)jjte000;}
11585     } finally {
11586          if (jjtc000) {
11587            jjtree.closeNodeScope(jjtn000, true);
11588          }
11589     }
11590     throw new Error("Missing return statement in function");
11591   }
11592 
11593 /** Scope rule: the loop index only exists within the Loop */
11594   final public ASTForStatement ForStatement() throws ParseException {
11595  /*@bgen(jjtree) ForStatement */
11596   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11597   boolean jjtc000 = true;
11598   jjtree.openNodeScope(jjtn000);
11599     try {
11600       jj_consume_token(FOR);
11601       ForIndex();
11602       jj_consume_token(IN);
11603       switch (jj_nt.kind) {
11604       case REVERSE:
11605         jj_consume_token(REVERSE);
11606         break;
11607       default:
11608         jj_la1[133] = jj_gen;
11609         ;
11610       }
11611       Expression();
11612       switch (jj_nt.kind) {
11613       case 12:
11614         jj_consume_token(12);
11615         Expression();
11616         break;
11617       default:
11618         jj_la1[134] = jj_gen;
11619         ;
11620       }
11621       jj_consume_token(LOOP);
11622       label_30:
11623       while (true) {
11624         Statement();
11625         switch (jj_nt.kind) {
11626         case 5:
11627         case 16:
11628         case 17:
11629         case 21:
11630         case REPLACE:
11631         case DEFINER:
11632         case CURRENT_USER:
11633         case LANGUAGE:
11634         case INLINE:
11635         case ADD:
11636         case AGGREGATE:
11637         case ARRAY:
11638         case AT:
11639         case ATTRIBUTE:
11640         case AUTHID:
11641         case BEGIN:
11642         case BODY:
11643         case BULK:
11644         case BYTE:
11645         case CASCADE:
11646         case CASE:
11647         case CLOSE:
11648         case COALESCE:
11649         case COLLECT:
11650         case COLUMN:
11651         case COMMENT:
11652         case COMMIT:
11653         case CONSTRUCTOR:
11654         case CONTINUE:
11655         case CONVERT:
11656         case CURRENT:
11657         case CURSOR:
11658         case DATA:
11659         case DATE:
11660         case DAY:
11661         case DECLARE:
11662         case DELETE:
11663         case DISABLE:
11664         case EDITIONABLE:
11665         case ELEMENT:
11666         case ENABLE:
11667         case ESCAPE:
11668         case EXCEPT:
11669         case EXCEPTIONS:
11670         case EXECUTE:
11671         case EXIT:
11672         case EXTERNAL:
11673         case EXTENDS:
11674         case EXTRACT:
11675         case FALSE:
11676         case FETCH:
11677         case FINAL:
11678         case FOR:
11679         case FORALL:
11680         case FORCE:
11681         case FUNCTION:
11682         case GLOBAL:
11683         case GOTO:
11684         case HASH:
11685         case HEAP:
11686         case HOUR:
11687         case IF:
11688         case IMMEDIATE:
11689         case INDICES:
11690         case INDEXTYPE:
11691         case INDICATOR:
11692         case INSERT:
11693         case INSTANTIABLE:
11694         case INTERVAL:
11695         case INVALIDATE:
11696         case ISOLATION:
11697         case JAVA:
11698         case LEVEL:
11699         case LIMIT:
11700         case LOCK:
11701         case LOOP:
11702         case MAP:
11703         case MAX:
11704         case MEMBER:
11705         case MERGE:
11706         case MIN:
11707         case MINUTE:
11708         case MLSLABEL:
11709         case MODIFY:
11710         case MOD:
11711         case MONTH:
11712         case NATURAL:
11713         case NEW:
11714         case NEW_DOT:
11715         case NO:
11716         case NONEDITIONABLE:
11717         case NOT:
11718         case NULL:
11719         case NULLIF:
11720         case OBJECT:
11721         case OID:
11722         case OPAQUE:
11723         case OPEN:
11724         case OPERATOR:
11725         case ORGANIZATION:
11726         case OTHERS:
11727         case OVERRIDING:
11728         case PACKAGE:
11729         case PARTITION:
11730         case PIPE:
11731         case PRAGMA:
11732         case PRESERVE:
11733         case PRIVATE:
11734         case PROCEDURE:
11735         case RAISE:
11736         case RANGE:
11737         case RAW:
11738         case REAL:
11739         case RECORD:
11740         case REF:
11741         case RELEASE:
11742         case RELIES_ON:
11743         case RENAME:
11744         case RESULT:
11745         case RETURN:
11746         case RETURNING:
11747         case REVERSE:
11748         case ROLLBACK:
11749         case ROW:
11750         case ROWS:
11751         case ROWID:
11752         case ROWNUM:
11753         case SAVE:
11754         case SAVEPOINT:
11755         case SECOND:
11756         case SELECT:
11757         case SELF:
11758         case SET:
11759         case SPACE:
11760         case SQL:
11761         case SQLCODE:
11762         case SQLERRM:
11763         case STATIC:
11764         case SUBTYPE:
11765         case SUBSTITUTABLE:
11766         case SUCCESSFUL:
11767         case SYSDATE:
11768         case SYS_REFCURSOR:
11769         case TEMPORARY:
11770         case TIME:
11771         case TIMESTAMP:
11772         case TIMEZONE_REGION:
11773         case TIMEZONE_ABBR:
11774         case TIMEZONE_MINUTE:
11775         case TIMEZONE_HOUR:
11776         case TRANSACTION:
11777         case TRUE:
11778         case TYPE:
11779         case UNDER:
11780         case USING:
11781         case WHILE:
11782         case YES:
11783         case SHOW:
11784         case A:
11785         case UPDATE:
11786         case DOUBLE:
11787         case DEC:
11788         case PRECISION:
11789         case INT:
11790         case NUMERIC:
11791         case NCHAR:
11792         case NVARCHAR2:
11793         case STRING:
11794         case UROWID:
11795         case VARRAY:
11796         case VARYING:
11797         case BFILE:
11798         case BLOB:
11799         case CLOB:
11800         case NCLOB:
11801         case YEAR:
11802         case LOCAL:
11803         case WITH:
11804         case ZONE:
11805         case CHARACTER:
11806         case AFTER:
11807         case BEFORE:
11808         case OLD:
11809         case PARENT:
11810         case CC_IF:
11811         case CC_ERROR:
11812         case ANALYZE:
11813         case ASSOCIATE:
11814         case AUDIT:
11815         case COMPOUND:
11816         case DATABASE:
11817         case CALL:
11818         case DDL:
11819         case DISASSOCIATE:
11820         case EACH:
11821         case FOLLOWS:
11822         case LOGOFF:
11823         case LOGON:
11824         case NESTED:
11825         case NOAUDIT:
11826         case SCHEMA:
11827         case SERVERERROR:
11828         case SHUTDOWN:
11829         case STARTUP:
11830         case STATEMENT:
11831         case STATISTICS:
11832         case SUSPEND:
11833         case TRUNCATE:
11834         case WRAPPED:
11835         case LIBRARY:
11836         case NAME:
11837         case STRUCT:
11838         case CONTEXT:
11839         case PARAMETERS:
11840         case LENGTH:
11841         case TDO:
11842         case MAXLEN:
11843         case CHARSETID:
11844         case CHARSETFORM:
11845         case ACCEPT:
11846         case ACCESSIBLE:
11847         case COPY:
11848         case DEFINE:
11849         case DISCONNECT:
11850         case HOST:
11851         case PRINT:
11852         case QUIT:
11853         case REMARK:
11854         case UNDEFINE:
11855         case VARIABLE:
11856         case WHENEVER:
11857         case ATTACH:
11858         case CAST:
11859         case TREAT:
11860         case TRIM:
11861         case LEFT:
11862         case RIGHT:
11863         case BOTH:
11864         case EMPTY:
11865         case MULTISET:
11866         case SUBMULTISET:
11867         case LEADING:
11868         case TRAILING:
11869         case CHAR_CS:
11870         case NCHAR_CS:
11871         case DBTIMEZONE:
11872         case SESSIONTIMEZONE:
11873         case AUTHENTICATED:
11874         case LINK:
11875         case SHARED:
11876         case DIRECTORY:
11877         case USER:
11878         case IDENTIFIER:
11879         case UNSIGNED_NUMERIC_LITERAL:
11880         case CHARACTER_LITERAL:
11881         case STRING_LITERAL:
11882         case QUOTED_LITERAL:
11883           ;
11884           break;
11885         default:
11886           jj_la1[135] = jj_gen;
11887           break label_30;
11888         }
11889       }
11890       jj_consume_token(END);
11891       jj_consume_token(LOOP);
11892       switch (jj_nt.kind) {
11893       case IDENTIFIER:
11894         jj_consume_token(IDENTIFIER);
11895         break;
11896       default:
11897         jj_la1[136] = jj_gen;
11898         ;
11899       }
11900         jjtree.closeNodeScope(jjtn000, true);
11901         jjtc000 = false;
11902         {if (true) return jjtn000 ;}
11903     } catch (Throwable jjte000) {
11904            if (jjtc000) {
11905              jjtree.clearNodeScope(jjtn000);
11906              jjtc000 = false;
11907            } else {
11908              jjtree.popNode();
11909            }
11910            if (jjte000 instanceof RuntimeException) {
11911              {if (true) throw (RuntimeException)jjte000;}
11912            }
11913            if (jjte000 instanceof ParseException) {
11914              {if (true) throw (ParseException)jjte000;}
11915            }
11916            {if (true) throw (Error)jjte000;}
11917     } finally {
11918            if (jjtc000) {
11919              jjtree.closeNodeScope(jjtn000, true);
11920            }
11921     }
11922     throw new Error("Missing return statement in function");
11923   }
11924 
11925   final public ASTWhileStatement WhileStatement() throws ParseException {
11926  /*@bgen(jjtree) WhileStatement */
11927   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11928   boolean jjtc000 = true;
11929   jjtree.openNodeScope(jjtn000);
11930     try {
11931       jj_consume_token(WHILE);
11932       Expression();
11933       jj_consume_token(LOOP);
11934       label_31:
11935       while (true) {
11936         Statement();
11937         switch (jj_nt.kind) {
11938         case 5:
11939         case 16:
11940         case 17:
11941         case 21:
11942         case REPLACE:
11943         case DEFINER:
11944         case CURRENT_USER:
11945         case LANGUAGE:
11946         case INLINE:
11947         case ADD:
11948         case AGGREGATE:
11949         case ARRAY:
11950         case AT:
11951         case ATTRIBUTE:
11952         case AUTHID:
11953         case BEGIN:
11954         case BODY:
11955         case BULK:
11956         case BYTE:
11957         case CASCADE:
11958         case CASE:
11959         case CLOSE:
11960         case COALESCE:
11961         case COLLECT:
11962         case COLUMN:
11963         case COMMENT:
11964         case COMMIT:
11965         case CONSTRUCTOR:
11966         case CONTINUE:
11967         case CONVERT:
11968         case CURRENT:
11969         case CURSOR:
11970         case DATA:
11971         case DATE:
11972         case DAY:
11973         case DECLARE:
11974         case DELETE:
11975         case DISABLE:
11976         case EDITIONABLE:
11977         case ELEMENT:
11978         case ENABLE:
11979         case ESCAPE:
11980         case EXCEPT:
11981         case EXCEPTIONS:
11982         case EXECUTE:
11983         case EXIT:
11984         case EXTERNAL:
11985         case EXTENDS:
11986         case EXTRACT:
11987         case FALSE:
11988         case FETCH:
11989         case FINAL:
11990         case FOR:
11991         case FORALL:
11992         case FORCE:
11993         case FUNCTION:
11994         case GLOBAL:
11995         case GOTO:
11996         case HASH:
11997         case HEAP:
11998         case HOUR:
11999         case IF:
12000         case IMMEDIATE:
12001         case INDICES:
12002         case INDEXTYPE:
12003         case INDICATOR:
12004         case INSERT:
12005         case INSTANTIABLE:
12006         case INTERVAL:
12007         case INVALIDATE:
12008         case ISOLATION:
12009         case JAVA:
12010         case LEVEL:
12011         case LIMIT:
12012         case LOCK:
12013         case LOOP:
12014         case MAP:
12015         case MAX:
12016         case MEMBER:
12017         case MERGE:
12018         case MIN:
12019         case MINUTE:
12020         case MLSLABEL:
12021         case MODIFY:
12022         case MOD:
12023         case MONTH:
12024         case NATURAL:
12025         case NEW:
12026         case NEW_DOT:
12027         case NO:
12028         case NONEDITIONABLE:
12029         case NOT:
12030         case NULL:
12031         case NULLIF:
12032         case OBJECT:
12033         case OID:
12034         case OPAQUE:
12035         case OPEN:
12036         case OPERATOR:
12037         case ORGANIZATION:
12038         case OTHERS:
12039         case OVERRIDING:
12040         case PACKAGE:
12041         case PARTITION:
12042         case PIPE:
12043         case PRAGMA:
12044         case PRESERVE:
12045         case PRIVATE:
12046         case PROCEDURE:
12047         case RAISE:
12048         case RANGE:
12049         case RAW:
12050         case REAL:
12051         case RECORD:
12052         case REF:
12053         case RELEASE:
12054         case RELIES_ON:
12055         case RENAME:
12056         case RESULT:
12057         case RETURN:
12058         case RETURNING:
12059         case REVERSE:
12060         case ROLLBACK:
12061         case ROW:
12062         case ROWS:
12063         case ROWID:
12064         case ROWNUM:
12065         case SAVE:
12066         case SAVEPOINT:
12067         case SECOND:
12068         case SELECT:
12069         case SELF:
12070         case SET:
12071         case SPACE:
12072         case SQL:
12073         case SQLCODE:
12074         case SQLERRM:
12075         case STATIC:
12076         case SUBTYPE:
12077         case SUBSTITUTABLE:
12078         case SUCCESSFUL:
12079         case SYSDATE:
12080         case SYS_REFCURSOR:
12081         case TEMPORARY:
12082         case TIME:
12083         case TIMESTAMP:
12084         case TIMEZONE_REGION:
12085         case TIMEZONE_ABBR:
12086         case TIMEZONE_MINUTE:
12087         case TIMEZONE_HOUR:
12088         case TRANSACTION:
12089         case TRUE:
12090         case TYPE:
12091         case UNDER:
12092         case USING:
12093         case WHILE:
12094         case YES:
12095         case SHOW:
12096         case A:
12097         case UPDATE:
12098         case DOUBLE:
12099         case DEC:
12100         case PRECISION:
12101         case INT:
12102         case NUMERIC:
12103         case NCHAR:
12104         case NVARCHAR2:
12105         case STRING:
12106         case UROWID:
12107         case VARRAY:
12108         case VARYING:
12109         case BFILE:
12110         case BLOB:
12111         case CLOB:
12112         case NCLOB:
12113         case YEAR:
12114         case LOCAL:
12115         case WITH:
12116         case ZONE:
12117         case CHARACTER:
12118         case AFTER:
12119         case BEFORE:
12120         case OLD:
12121         case PARENT:
12122         case CC_IF:
12123         case CC_ERROR:
12124         case ANALYZE:
12125         case ASSOCIATE:
12126         case AUDIT:
12127         case COMPOUND:
12128         case DATABASE:
12129         case CALL:
12130         case DDL:
12131         case DISASSOCIATE:
12132         case EACH:
12133         case FOLLOWS:
12134         case LOGOFF:
12135         case LOGON:
12136         case NESTED:
12137         case NOAUDIT:
12138         case SCHEMA:
12139         case SERVERERROR:
12140         case SHUTDOWN:
12141         case STARTUP:
12142         case STATEMENT:
12143         case STATISTICS:
12144         case SUSPEND:
12145         case TRUNCATE:
12146         case WRAPPED:
12147         case LIBRARY:
12148         case NAME:
12149         case STRUCT:
12150         case CONTEXT:
12151         case PARAMETERS:
12152         case LENGTH:
12153         case TDO:
12154         case MAXLEN:
12155         case CHARSETID:
12156         case CHARSETFORM:
12157         case ACCEPT:
12158         case ACCESSIBLE:
12159         case COPY:
12160         case DEFINE:
12161         case DISCONNECT:
12162         case HOST:
12163         case PRINT:
12164         case QUIT:
12165         case REMARK:
12166         case UNDEFINE:
12167         case VARIABLE:
12168         case WHENEVER:
12169         case ATTACH:
12170         case CAST:
12171         case TREAT:
12172         case TRIM:
12173         case LEFT:
12174         case RIGHT:
12175         case BOTH:
12176         case EMPTY:
12177         case MULTISET:
12178         case SUBMULTISET:
12179         case LEADING:
12180         case TRAILING:
12181         case CHAR_CS:
12182         case NCHAR_CS:
12183         case DBTIMEZONE:
12184         case SESSIONTIMEZONE:
12185         case AUTHENTICATED:
12186         case LINK:
12187         case SHARED:
12188         case DIRECTORY:
12189         case USER:
12190         case IDENTIFIER:
12191         case UNSIGNED_NUMERIC_LITERAL:
12192         case CHARACTER_LITERAL:
12193         case STRING_LITERAL:
12194         case QUOTED_LITERAL:
12195           ;
12196           break;
12197         default:
12198           jj_la1[137] = jj_gen;
12199           break label_31;
12200         }
12201       }
12202       jj_consume_token(END);
12203       jj_consume_token(LOOP);
12204       switch (jj_nt.kind) {
12205       case IDENTIFIER:
12206         jj_consume_token(IDENTIFIER);
12207         break;
12208       default:
12209         jj_la1[138] = jj_gen;
12210         ;
12211       }
12212         jjtree.closeNodeScope(jjtn000, true);
12213         jjtc000 = false;
12214         {if (true) return jjtn000 ;}
12215     } catch (Throwable jjte000) {
12216            if (jjtc000) {
12217              jjtree.clearNodeScope(jjtn000);
12218              jjtc000 = false;
12219            } else {
12220              jjtree.popNode();
12221            }
12222            if (jjte000 instanceof RuntimeException) {
12223              {if (true) throw (RuntimeException)jjte000;}
12224            }
12225            if (jjte000 instanceof ParseException) {
12226              {if (true) throw (ParseException)jjte000;}
12227            }
12228            {if (true) throw (Error)jjte000;}
12229     } finally {
12230            if (jjtc000) {
12231              jjtree.closeNodeScope(jjtn000, true);
12232            }
12233     }
12234     throw new Error("Missing return statement in function");
12235   }
12236 
12237   final public ASTIfStatement IfStatement() throws ParseException {
12238  /*@bgen(jjtree) IfStatement */
12239   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12240   boolean jjtc000 = true;
12241   jjtree.openNodeScope(jjtn000);
12242     try {
12243       jj_consume_token(IF);
12244       Expression();
12245       jj_consume_token(THEN);
12246       label_32:
12247       while (true) {
12248         Statement();
12249         switch (jj_nt.kind) {
12250         case 5:
12251         case 16:
12252         case 17:
12253         case 21:
12254         case REPLACE:
12255         case DEFINER:
12256         case CURRENT_USER:
12257         case LANGUAGE:
12258         case INLINE:
12259         case ADD:
12260         case AGGREGATE:
12261         case ARRAY:
12262         case AT:
12263         case ATTRIBUTE:
12264         case AUTHID:
12265         case BEGIN:
12266         case BODY:
12267         case BULK:
12268         case BYTE:
12269         case CASCADE:
12270         case CASE:
12271         case CLOSE:
12272         case COALESCE:
12273         case COLLECT:
12274         case COLUMN:
12275         case COMMENT:
12276         case COMMIT:
12277         case CONSTRUCTOR:
12278         case CONTINUE:
12279         case CONVERT:
12280         case CURRENT:
12281         case CURSOR:
12282         case DATA:
12283         case DATE:
12284         case DAY:
12285         case DECLARE:
12286         case DELETE:
12287         case DISABLE:
12288         case EDITIONABLE:
12289         case ELEMENT:
12290         case ENABLE:
12291         case ESCAPE:
12292         case EXCEPT:
12293         case EXCEPTIONS:
12294         case EXECUTE:
12295         case EXIT:
12296         case EXTERNAL:
12297         case EXTENDS:
12298         case EXTRACT:
12299         case FALSE:
12300         case FETCH:
12301         case FINAL:
12302         case FOR:
12303         case FORALL:
12304         case FORCE:
12305         case FUNCTION:
12306         case GLOBAL:
12307         case GOTO:
12308         case HASH:
12309         case HEAP:
12310         case HOUR:
12311         case IF:
12312         case IMMEDIATE:
12313         case INDICES:
12314         case INDEXTYPE:
12315         case INDICATOR:
12316         case INSERT:
12317         case INSTANTIABLE:
12318         case INTERVAL:
12319         case INVALIDATE:
12320         case ISOLATION:
12321         case JAVA:
12322         case LEVEL:
12323         case LIMIT:
12324         case LOCK:
12325         case LOOP:
12326         case MAP:
12327         case MAX:
12328         case MEMBER:
12329         case MERGE:
12330         case MIN:
12331         case MINUTE:
12332         case MLSLABEL:
12333         case MODIFY:
12334         case MOD:
12335         case MONTH:
12336         case NATURAL:
12337         case NEW:
12338         case NEW_DOT:
12339         case NO:
12340         case NONEDITIONABLE:
12341         case NOT:
12342         case NULL:
12343         case NULLIF:
12344         case OBJECT:
12345         case OID:
12346         case OPAQUE:
12347         case OPEN:
12348         case OPERATOR:
12349         case ORGANIZATION:
12350         case OTHERS:
12351         case OVERRIDING:
12352         case PACKAGE:
12353         case PARTITION:
12354         case PIPE:
12355         case PRAGMA:
12356         case PRESERVE:
12357         case PRIVATE:
12358         case PROCEDURE:
12359         case RAISE:
12360         case RANGE:
12361         case RAW:
12362         case REAL:
12363         case RECORD:
12364         case REF:
12365         case RELEASE:
12366         case RELIES_ON:
12367         case RENAME:
12368         case RESULT:
12369         case RETURN:
12370         case RETURNING:
12371         case REVERSE:
12372         case ROLLBACK:
12373         case ROW:
12374         case ROWS:
12375         case ROWID:
12376         case ROWNUM:
12377         case SAVE:
12378         case SAVEPOINT:
12379         case SECOND:
12380         case SELECT:
12381         case SELF:
12382         case SET:
12383         case SPACE:
12384         case SQL:
12385         case SQLCODE:
12386         case SQLERRM:
12387         case STATIC:
12388         case SUBTYPE:
12389         case SUBSTITUTABLE:
12390         case SUCCESSFUL:
12391         case SYSDATE:
12392         case SYS_REFCURSOR:
12393         case TEMPORARY:
12394         case TIME:
12395         case TIMESTAMP:
12396         case TIMEZONE_REGION:
12397         case TIMEZONE_ABBR:
12398         case TIMEZONE_MINUTE:
12399         case TIMEZONE_HOUR:
12400         case TRANSACTION:
12401         case TRUE:
12402         case TYPE:
12403         case UNDER:
12404         case USING:
12405         case WHILE:
12406         case YES:
12407         case SHOW:
12408         case A:
12409         case UPDATE:
12410         case DOUBLE:
12411         case DEC:
12412         case PRECISION:
12413         case INT:
12414         case NUMERIC:
12415         case NCHAR:
12416         case NVARCHAR2:
12417         case STRING:
12418         case UROWID:
12419         case VARRAY:
12420         case VARYING:
12421         case BFILE:
12422         case BLOB:
12423         case CLOB:
12424         case NCLOB:
12425         case YEAR:
12426         case LOCAL:
12427         case WITH:
12428         case ZONE:
12429         case CHARACTER:
12430         case AFTER:
12431         case BEFORE:
12432         case OLD:
12433         case PARENT:
12434         case CC_IF:
12435         case CC_ERROR:
12436         case ANALYZE:
12437         case ASSOCIATE:
12438         case AUDIT:
12439         case COMPOUND:
12440         case DATABASE:
12441         case CALL:
12442         case DDL:
12443         case DISASSOCIATE:
12444         case EACH:
12445         case FOLLOWS:
12446         case LOGOFF:
12447         case LOGON:
12448         case NESTED:
12449         case NOAUDIT:
12450         case SCHEMA:
12451         case SERVERERROR:
12452         case SHUTDOWN:
12453         case STARTUP:
12454         case STATEMENT:
12455         case STATISTICS:
12456         case SUSPEND:
12457         case TRUNCATE:
12458         case WRAPPED:
12459         case LIBRARY:
12460         case NAME:
12461         case STRUCT:
12462         case CONTEXT:
12463         case PARAMETERS:
12464         case LENGTH:
12465         case TDO:
12466         case MAXLEN:
12467         case CHARSETID:
12468         case CHARSETFORM:
12469         case ACCEPT:
12470         case ACCESSIBLE:
12471         case COPY:
12472         case DEFINE:
12473         case DISCONNECT:
12474         case HOST:
12475         case PRINT:
12476         case QUIT:
12477         case REMARK:
12478         case UNDEFINE:
12479         case VARIABLE:
12480         case WHENEVER:
12481         case ATTACH:
12482         case CAST:
12483         case TREAT:
12484         case TRIM:
12485         case LEFT:
12486         case RIGHT:
12487         case BOTH:
12488         case EMPTY:
12489         case MULTISET:
12490         case SUBMULTISET:
12491         case LEADING:
12492         case TRAILING:
12493         case CHAR_CS:
12494         case NCHAR_CS:
12495         case DBTIMEZONE:
12496         case SESSIONTIMEZONE:
12497         case AUTHENTICATED:
12498         case LINK:
12499         case SHARED:
12500         case DIRECTORY:
12501         case USER:
12502         case IDENTIFIER:
12503         case UNSIGNED_NUMERIC_LITERAL:
12504         case CHARACTER_LITERAL:
12505         case STRING_LITERAL:
12506         case QUOTED_LITERAL:
12507           ;
12508           break;
12509         default:
12510           jj_la1[139] = jj_gen;
12511           break label_32;
12512         }
12513       }
12514       label_33:
12515       while (true) {
12516         switch (jj_nt.kind) {
12517         case ELSIF:
12518           ;
12519           break;
12520         default:
12521           jj_la1[140] = jj_gen;
12522           break label_33;
12523         }
12524         ElsifClause();
12525                          jjtn000.setHasElse();
12526       }
12527       switch (jj_nt.kind) {
12528       case ELSE:
12529         ElseClause();
12530                         jjtn000.setHasElse();
12531         break;
12532       default:
12533         jj_la1[141] = jj_gen;
12534         ;
12535       }
12536       jj_consume_token(END);
12537       jj_consume_token(IF);
12538         jjtree.closeNodeScope(jjtn000, true);
12539         jjtc000 = false;
12540         {if (true) return jjtn000 ;}
12541     } catch (Throwable jjte000) {
12542           if (jjtc000) {
12543             jjtree.clearNodeScope(jjtn000);
12544             jjtc000 = false;
12545           } else {
12546             jjtree.popNode();
12547           }
12548           if (jjte000 instanceof RuntimeException) {
12549             {if (true) throw (RuntimeException)jjte000;}
12550           }
12551           if (jjte000 instanceof ParseException) {
12552             {if (true) throw (ParseException)jjte000;}
12553           }
12554           {if (true) throw (Error)jjte000;}
12555     } finally {
12556           if (jjtc000) {
12557             jjtree.closeNodeScope(jjtn000, true);
12558           }
12559     }
12560     throw new Error("Missing return statement in function");
12561   }
12562 
12563 /** Scope rule: the loop index only exists within the statement */
12564 /**
12565 ForIndex is declared implicitly, unlike most variables or constants.
12566 */
12567   final public ASTForIndex ForIndex() throws ParseException {
12568  /*@bgen(jjtree) ForIndex */
12569  ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12570  boolean jjtc000 = true;
12571  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12572     try {
12573       simpleNode = ID();
12574    jjtree.closeNodeScope(jjtn000, true);
12575    jjtc000 = false;
12576    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12577     } catch (Throwable jjte000) {
12578    if (jjtc000) {
12579      jjtree.clearNodeScope(jjtn000);
12580      jjtc000 = false;
12581    } else {
12582      jjtree.popNode();
12583    }
12584    if (jjte000 instanceof RuntimeException) {
12585      {if (true) throw (RuntimeException)jjte000;}
12586    }
12587    if (jjte000 instanceof ParseException) {
12588      {if (true) throw (ParseException)jjte000;}
12589    }
12590    {if (true) throw (Error)jjte000;}
12591     } finally {
12592    if (jjtc000) {
12593      jjtree.closeNodeScope(jjtn000, true);
12594    }
12595     }
12596     throw new Error("Missing return statement in function");
12597   }
12598 
12599 /**
12600 ForAllIndex is declared implicitly, unlike most variables or constants.
12601 */
12602   final public ASTForAllIndex ForAllIndex() throws ParseException {
12603  /*@bgen(jjtree) ForAllIndex */
12604  ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12605  boolean jjtc000 = true;
12606  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12607     try {
12608       simpleNode = ID();
12609    jjtree.closeNodeScope(jjtn000, true);
12610    jjtc000 = false;
12611    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12612     } catch (Throwable jjte000) {
12613    if (jjtc000) {
12614      jjtree.clearNodeScope(jjtn000);
12615      jjtc000 = false;
12616    } else {
12617      jjtree.popNode();
12618    }
12619    if (jjte000 instanceof RuntimeException) {
12620      {if (true) throw (RuntimeException)jjte000;}
12621    }
12622    if (jjte000 instanceof ParseException) {
12623      {if (true) throw (ParseException)jjte000;}
12624    }
12625    {if (true) throw (Error)jjte000;}
12626     } finally {
12627    if (jjtc000) {
12628      jjtree.closeNodeScope(jjtn000, true);
12629    }
12630     }
12631     throw new Error("Missing return statement in function");
12632   }
12633 
12634   final public ASTForAllStatement ForAllStatement() throws ParseException {
12635  /*@bgen(jjtree) ForAllStatement */
12636   ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12637   boolean jjtc000 = true;
12638   jjtree.openNodeScope(jjtn000);
12639     try {
12640       jj_consume_token(FORALL);
12641       ForAllIndex();
12642       jj_consume_token(IN);
12643       switch (jj_nt.kind) {
12644       case INDICES:
12645       case VALUES:
12646         switch (jj_nt.kind) {
12647         case INDICES:
12648           jj_consume_token(INDICES);
12649           break;
12650         case VALUES:
12651           jj_consume_token(VALUES);
12652           break;
12653         default:
12654           jj_la1[142] = jj_gen;
12655           jj_consume_token(-1);
12656           throw new ParseException();
12657         }
12658         jj_consume_token(OF);
12659         Expression();
12660         break;
12661       case 5:
12662       case 16:
12663       case 17:
12664       case REPLACE:
12665       case DEFINER:
12666       case CURRENT_USER:
12667       case LANGUAGE:
12668       case INLINE:
12669       case ADD:
12670       case AGGREGATE:
12671       case ARRAY:
12672       case AT:
12673       case ATTRIBUTE:
12674       case AUTHID:
12675       case BODY:
12676       case BULK:
12677       case BYTE:
12678       case CASCADE:
12679       case CASE:
12680       case CLOSE:
12681       case COALESCE:
12682       case COLLECT:
12683       case COLUMN:
12684       case COMMENT:
12685       case COMMIT:
12686       case CONSTRUCTOR:
12687       case CONTINUE:
12688       case CONVERT:
12689       case CURRENT:
12690       case CURSOR:
12691       case DATA:
12692       case DATE:
12693       case DAY:
12694       case DISABLE:
12695       case EDITIONABLE:
12696       case ELEMENT:
12697       case ENABLE:
12698       case ESCAPE:
12699       case EXCEPT:
12700       case EXCEPTIONS:
12701       case EXIT:
12702       case EXTERNAL:
12703       case EXTENDS:
12704       case EXTRACT:
12705       case FALSE:
12706       case FINAL:
12707       case FORCE:
12708       case FUNCTION:
12709       case GLOBAL:
12710       case HASH:
12711       case HEAP:
12712       case HOUR:
12713       case IMMEDIATE:
12714       case INDEXTYPE:
12715       case INDICATOR:
12716       case INSTANTIABLE:
12717       case INTERVAL:
12718       case INVALIDATE:
12719       case ISOLATION:
12720       case JAVA:
12721       case LEVEL:
12722       case LIMIT:
12723       case LOOP:
12724       case MAP:
12725       case MAX:
12726       case MEMBER:
12727       case MERGE:
12728       case MIN:
12729       case MINUTE:
12730       case MLSLABEL:
12731       case MODIFY:
12732       case MOD:
12733       case MONTH:
12734       case NATURAL:
12735       case NEW:
12736       case NEW_DOT:
12737       case NO:
12738       case NONEDITIONABLE:
12739       case NOT:
12740       case NULL:
12741       case NULLIF:
12742       case OBJECT:
12743       case OID:
12744       case OPAQUE:
12745       case OPEN:
12746       case OPERATOR:
12747       case ORGANIZATION:
12748       case OTHERS:
12749       case OVERRIDING:
12750       case PACKAGE:
12751       case PARTITION:
12752       case PRESERVE:
12753       case PRIVATE:
12754       case PROCEDURE:
12755       case RANGE:
12756       case RAW:
12757       case REAL:
12758       case RECORD:
12759       case REF:
12760       case RELEASE:
12761       case RELIES_ON:
12762       case RENAME:
12763       case RESULT:
12764       case RETURN:
12765       case RETURNING:
12766       case REVERSE:
12767       case ROLLBACK:
12768       case ROW:
12769       case ROWS:
12770       case ROWID:
12771       case ROWNUM:
12772       case SAVE:
12773       case SAVEPOINT:
12774       case SECOND:
12775       case SELECT:
12776       case SELF:
12777       case SET:
12778       case SPACE:
12779       case SQL:
12780       case SQLCODE:
12781       case SQLERRM:
12782       case STATIC:
12783       case SUBTYPE:
12784       case SUBSTITUTABLE:
12785       case SUCCESSFUL:
12786       case SYSDATE:
12787       case SYS_REFCURSOR:
12788       case TEMPORARY:
12789       case TIME:
12790       case TIMESTAMP:
12791       case TIMEZONE_REGION:
12792       case TIMEZONE_ABBR:
12793       case TIMEZONE_MINUTE:
12794       case TIMEZONE_HOUR:
12795       case TRANSACTION:
12796       case TRUE:
12797       case TYPE:
12798       case UNDER:
12799       case USING:
12800       case YES:
12801       case SHOW:
12802       case A:
12803       case DOUBLE:
12804       case DEC:
12805       case PRECISION:
12806       case INT:
12807       case NUMERIC:
12808       case NCHAR:
12809       case NVARCHAR2:
12810       case STRING:
12811       case UROWID:
12812       case VARRAY:
12813       case VARYING:
12814       case BFILE:
12815       case BLOB:
12816       case CLOB:
12817       case NCLOB:
12818       case YEAR:
12819       case LOCAL:
12820       case WITH:
12821       case ZONE:
12822       case CHARACTER:
12823       case AFTER:
12824       case BEFORE:
12825       case OLD:
12826       case PARENT:
12827       case CC_IF:
12828       case ANALYZE:
12829       case ASSOCIATE:
12830       case AUDIT:
12831       case COMPOUND:
12832       case DATABASE:
12833       case CALL:
12834       case DDL:
12835       case DISASSOCIATE:
12836       case EACH:
12837       case FOLLOWS:
12838       case LOGOFF:
12839       case LOGON:
12840       case NESTED:
12841       case NOAUDIT:
12842       case SCHEMA:
12843       case SERVERERROR:
12844       case SHUTDOWN:
12845       case STARTUP:
12846       case STATEMENT:
12847       case STATISTICS:
12848       case SUSPEND:
12849       case TRUNCATE:
12850       case WRAPPED:
12851       case LIBRARY:
12852       case NAME:
12853       case STRUCT:
12854       case CONTEXT:
12855       case PARAMETERS:
12856       case LENGTH:
12857       case TDO:
12858       case MAXLEN:
12859       case CHARSETID:
12860       case CHARSETFORM:
12861       case ACCEPT:
12862       case ACCESSIBLE:
12863       case COPY:
12864       case DEFINE:
12865       case DISCONNECT:
12866       case HOST:
12867       case PRINT:
12868       case QUIT:
12869       case REMARK:
12870       case UNDEFINE:
12871       case VARIABLE:
12872       case WHENEVER:
12873       case ATTACH:
12874       case CAST:
12875       case TREAT:
12876       case TRIM:
12877       case LEFT:
12878       case RIGHT:
12879       case BOTH:
12880       case EMPTY:
12881       case MULTISET:
12882       case SUBMULTISET:
12883       case LEADING:
12884       case TRAILING:
12885       case CHAR_CS:
12886       case NCHAR_CS:
12887       case DBTIMEZONE:
12888       case SESSIONTIMEZONE:
12889       case AUTHENTICATED:
12890       case LINK:
12891       case SHARED:
12892       case DIRECTORY:
12893       case USER:
12894       case IDENTIFIER:
12895       case UNSIGNED_NUMERIC_LITERAL:
12896       case CHARACTER_LITERAL:
12897       case STRING_LITERAL:
12898       case QUOTED_LITERAL:
12899         Expression();
12900         switch (jj_nt.kind) {
12901         case 12:
12902           jj_consume_token(12);
12903           Expression();
12904           break;
12905         default:
12906           jj_la1[143] = jj_gen;
12907           ;
12908         }
12909         break;
12910       default:
12911         jj_la1[144] = jj_gen;
12912         jj_consume_token(-1);
12913         throw new ParseException();
12914       }
12915       switch (jj_nt.kind) {
12916       case SAVE:
12917         jj_consume_token(SAVE);
12918         jj_consume_token(EXCEPTIONS);
12919         break;
12920       default:
12921         jj_la1[145] = jj_gen;
12922         ;
12923       }
12924       SqlStatement(null,";");
12925         jjtree.closeNodeScope(jjtn000, true);
12926         jjtc000 = false;
12927         {if (true) return jjtn000 ;}
12928     } catch (Throwable jjte000) {
12929            if (jjtc000) {
12930              jjtree.clearNodeScope(jjtn000);
12931              jjtc000 = false;
12932            } else {
12933              jjtree.popNode();
12934            }
12935            if (jjte000 instanceof RuntimeException) {
12936              {if (true) throw (RuntimeException)jjte000;}
12937            }
12938            if (jjte000 instanceof ParseException) {
12939              {if (true) throw (ParseException)jjte000;}
12940            }
12941            {if (true) throw (Error)jjte000;}
12942     } finally {
12943            if (jjtc000) {
12944              jjtree.closeNodeScope(jjtn000, true);
12945            }
12946     }
12947     throw new Error("Missing return statement in function");
12948   }
12949 
12950   final public ASTGotoStatement GotoStatement() throws ParseException {
12951  /*@bgen(jjtree) GotoStatement */
12952  ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12953  boolean jjtc000 = true;
12954  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12955     try {
12956       jj_consume_token(GOTO);
12957       label = QualifiedName();
12958         jjtree.closeNodeScope(jjtn000, true);
12959         jjtc000 = false;
12960         jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12961     } catch (Throwable jjte000) {
12962           if (jjtc000) {
12963             jjtree.clearNodeScope(jjtn000);
12964             jjtc000 = false;
12965           } else {
12966             jjtree.popNode();
12967           }
12968           if (jjte000 instanceof RuntimeException) {
12969             {if (true) throw (RuntimeException)jjte000;}
12970           }
12971           if (jjte000 instanceof ParseException) {
12972             {if (true) throw (ParseException)jjte000;}
12973           }
12974           {if (true) throw (Error)jjte000;}
12975     } finally {
12976           if (jjtc000) {
12977             jjtree.closeNodeScope(jjtn000, true);
12978           }
12979     }
12980     throw new Error("Missing return statement in function");
12981   }
12982 
12983   final public ASTReturnStatement ReturnStatement() throws ParseException {
12984  /*@bgen(jjtree) ReturnStatement */
12985   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12986   boolean jjtc000 = true;
12987   jjtree.openNodeScope(jjtn000);
12988     try {
12989       jj_consume_token(RETURN);
12990       switch (jj_nt.kind) {
12991       case 5:
12992       case 16:
12993       case 17:
12994       case REPLACE:
12995       case DEFINER:
12996       case CURRENT_USER:
12997       case LANGUAGE:
12998       case INLINE:
12999       case ADD:
13000       case AGGREGATE:
13001       case ARRAY:
13002       case AT:
13003       case ATTRIBUTE:
13004       case AUTHID:
13005       case BODY:
13006       case BULK:
13007       case BYTE:
13008       case CASCADE:
13009       case CASE:
13010       case CLOSE:
13011       case COALESCE:
13012       case COLLECT:
13013       case COLUMN:
13014       case COMMENT:
13015       case COMMIT:
13016       case CONSTRUCTOR:
13017       case CONTINUE:
13018       case CONVERT:
13019       case CURRENT:
13020       case CURSOR:
13021       case DATA:
13022       case DATE:
13023       case DAY:
13024       case DISABLE:
13025       case EDITIONABLE:
13026       case ELEMENT:
13027       case ENABLE:
13028       case ESCAPE:
13029       case EXCEPT:
13030       case EXCEPTIONS:
13031       case EXIT:
13032       case EXTERNAL:
13033       case EXTENDS:
13034       case EXTRACT:
13035       case FALSE:
13036       case FINAL:
13037       case FORCE:
13038       case FUNCTION:
13039       case GLOBAL:
13040       case HASH:
13041       case HEAP:
13042       case HOUR:
13043       case IMMEDIATE:
13044       case INDICES:
13045       case INDEXTYPE:
13046       case INDICATOR:
13047       case INSTANTIABLE:
13048       case INTERVAL:
13049       case INVALIDATE:
13050       case ISOLATION:
13051       case JAVA:
13052       case LEVEL:
13053       case LIMIT:
13054       case LOOP:
13055       case MAP:
13056       case MAX:
13057       case MEMBER:
13058       case MERGE:
13059       case MIN:
13060       case MINUTE:
13061       case MLSLABEL:
13062       case MODIFY:
13063       case MOD:
13064       case MONTH:
13065       case NATURAL:
13066       case NEW:
13067       case NEW_DOT:
13068       case NO:
13069       case NONEDITIONABLE:
13070       case NOT:
13071       case NULL:
13072       case NULLIF:
13073       case OBJECT:
13074       case OID:
13075       case OPAQUE:
13076       case OPEN:
13077       case OPERATOR:
13078       case ORGANIZATION:
13079       case OTHERS:
13080       case OVERRIDING:
13081       case PACKAGE:
13082       case PARTITION:
13083       case PRESERVE:
13084       case PRIVATE:
13085       case PROCEDURE:
13086       case RANGE:
13087       case RAW:
13088       case REAL:
13089       case RECORD:
13090       case REF:
13091       case RELEASE:
13092       case RELIES_ON:
13093       case RENAME:
13094       case RESULT:
13095       case RETURN:
13096       case RETURNING:
13097       case REVERSE:
13098       case ROLLBACK:
13099       case ROW:
13100       case ROWS:
13101       case ROWID:
13102       case ROWNUM:
13103       case SAVE:
13104       case SAVEPOINT:
13105       case SECOND:
13106       case SELECT:
13107       case SELF:
13108       case SET:
13109       case SPACE:
13110       case SQL:
13111       case SQLCODE:
13112       case SQLERRM:
13113       case STATIC:
13114       case SUBTYPE:
13115       case SUBSTITUTABLE:
13116       case SUCCESSFUL:
13117       case SYSDATE:
13118       case SYS_REFCURSOR:
13119       case TEMPORARY:
13120       case TIME:
13121       case TIMESTAMP:
13122       case TIMEZONE_REGION:
13123       case TIMEZONE_ABBR:
13124       case TIMEZONE_MINUTE:
13125       case TIMEZONE_HOUR:
13126       case TRANSACTION:
13127       case TRUE:
13128       case TYPE:
13129       case UNDER:
13130       case USING:
13131       case YES:
13132       case SHOW:
13133       case A:
13134       case DOUBLE:
13135       case DEC:
13136       case PRECISION:
13137       case INT:
13138       case NUMERIC:
13139       case NCHAR:
13140       case NVARCHAR2:
13141       case STRING:
13142       case UROWID:
13143       case VARRAY:
13144       case VARYING:
13145       case BFILE:
13146       case BLOB:
13147       case CLOB:
13148       case NCLOB:
13149       case YEAR:
13150       case LOCAL:
13151       case WITH:
13152       case ZONE:
13153       case CHARACTER:
13154       case AFTER:
13155       case BEFORE:
13156       case OLD:
13157       case PARENT:
13158       case CC_IF:
13159       case ANALYZE:
13160       case ASSOCIATE:
13161       case AUDIT:
13162       case COMPOUND:
13163       case DATABASE:
13164       case CALL:
13165       case DDL:
13166       case DISASSOCIATE:
13167       case EACH:
13168       case FOLLOWS:
13169       case LOGOFF:
13170       case LOGON:
13171       case NESTED:
13172       case NOAUDIT:
13173       case SCHEMA:
13174       case SERVERERROR:
13175       case SHUTDOWN:
13176       case STARTUP:
13177       case STATEMENT:
13178       case STATISTICS:
13179       case SUSPEND:
13180       case TRUNCATE:
13181       case WRAPPED:
13182       case LIBRARY:
13183       case NAME:
13184       case STRUCT:
13185       case CONTEXT:
13186       case PARAMETERS:
13187       case LENGTH:
13188       case TDO:
13189       case MAXLEN:
13190       case CHARSETID:
13191       case CHARSETFORM:
13192       case ACCEPT:
13193       case ACCESSIBLE:
13194       case COPY:
13195       case DEFINE:
13196       case DISCONNECT:
13197       case HOST:
13198       case PRINT:
13199       case QUIT:
13200       case REMARK:
13201       case UNDEFINE:
13202       case VARIABLE:
13203       case WHENEVER:
13204       case ATTACH:
13205       case CAST:
13206       case TREAT:
13207       case TRIM:
13208       case LEFT:
13209       case RIGHT:
13210       case BOTH:
13211       case EMPTY:
13212       case MULTISET:
13213       case SUBMULTISET:
13214       case LEADING:
13215       case TRAILING:
13216       case CHAR_CS:
13217       case NCHAR_CS:
13218       case DBTIMEZONE:
13219       case SESSIONTIMEZONE:
13220       case AUTHENTICATED:
13221       case LINK:
13222       case SHARED:
13223       case DIRECTORY:
13224       case USER:
13225       case IDENTIFIER:
13226       case UNSIGNED_NUMERIC_LITERAL:
13227       case CHARACTER_LITERAL:
13228       case STRING_LITERAL:
13229       case QUOTED_LITERAL:
13230         Expression();
13231         break;
13232       default:
13233         jj_la1[146] = jj_gen;
13234         ;
13235       }
13236         jjtree.closeNodeScope(jjtn000, true);
13237         jjtc000 = false;
13238         {if (true) return jjtn000 ;}
13239     } catch (Throwable jjte000) {
13240           if (jjtc000) {
13241             jjtree.clearNodeScope(jjtn000);
13242             jjtc000 = false;
13243           } else {
13244             jjtree.popNode();
13245           }
13246           if (jjte000 instanceof RuntimeException) {
13247             {if (true) throw (RuntimeException)jjte000;}
13248           }
13249           if (jjte000 instanceof ParseException) {
13250             {if (true) throw (ParseException)jjte000;}
13251           }
13252           {if (true) throw (Error)jjte000;}
13253     } finally {
13254           if (jjtc000) {
13255             jjtree.closeNodeScope(jjtn000, true);
13256           }
13257     }
13258     throw new Error("Missing return statement in function");
13259   }
13260 
13261   final public ASTContinueStatement ContinueStatement() throws ParseException {
13262  /*@bgen(jjtree) ContinueStatement */
13263  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13264  boolean jjtc000 = true;
13265  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13266     try {
13267       jj_consume_token(CONTINUE);
13268       switch (jj_nt.kind) {
13269       case REPLACE:
13270       case DEFINER:
13271       case CURRENT_USER:
13272       case LANGUAGE:
13273       case INLINE:
13274       case ADD:
13275       case AGGREGATE:
13276       case ARRAY:
13277       case AT:
13278       case ATTRIBUTE:
13279       case AUTHID:
13280       case BODY:
13281       case BULK:
13282       case BYTE:
13283       case CASCADE:
13284       case CLOSE:
13285       case COALESCE:
13286       case COLLECT:
13287       case COLUMN:
13288       case COMMENT:
13289       case COMMIT:
13290       case CONSTRUCTOR:
13291       case CONTINUE:
13292       case CONVERT:
13293       case CURRENT:
13294       case CURSOR:
13295       case DATA:
13296       case DAY:
13297       case DISABLE:
13298       case EDITIONABLE:
13299       case ELEMENT:
13300       case ENABLE:
13301       case ESCAPE:
13302       case EXCEPT:
13303       case EXCEPTIONS:
13304       case EXIT:
13305       case EXTERNAL:
13306       case EXTENDS:
13307       case EXTRACT:
13308       case FALSE:
13309       case FINAL:
13310       case FORCE:
13311       case FUNCTION:
13312       case GLOBAL:
13313       case HASH:
13314       case HEAP:
13315       case HOUR:
13316       case IMMEDIATE:
13317       case INDICES:
13318       case INDEXTYPE:
13319       case INDICATOR:
13320       case INSTANTIABLE:
13321       case INTERVAL:
13322       case INVALIDATE:
13323       case ISOLATION:
13324       case JAVA:
13325       case LEVEL:
13326       case LIMIT:
13327       case LOOP:
13328       case MAP:
13329       case MAX:
13330       case MEMBER:
13331       case MERGE:
13332       case MIN:
13333       case MINUTE:
13334       case MLSLABEL:
13335       case MODIFY:
13336       case MOD:
13337       case MONTH:
13338       case NATURAL:
13339       case NEW:
13340       case NO:
13341       case NONEDITIONABLE:
13342       case NULLIF:
13343       case OBJECT:
13344       case OID:
13345       case OPAQUE:
13346       case OPEN:
13347       case OPERATOR:
13348       case ORGANIZATION:
13349       case OTHERS:
13350       case OVERRIDING:
13351       case PACKAGE:
13352       case PARTITION:
13353       case PRESERVE:
13354       case PRIVATE:
13355       case PROCEDURE:
13356       case RANGE:
13357       case RAW:
13358       case REAL:
13359       case RECORD:
13360       case REF:
13361       case RELEASE:
13362       case RELIES_ON:
13363       case RENAME:
13364       case RESULT:
13365       case RETURN:
13366       case RETURNING:
13367       case REVERSE:
13368       case ROLLBACK:
13369       case ROW:
13370       case ROWS:
13371       case ROWID:
13372       case ROWNUM:
13373       case SAVE:
13374       case SAVEPOINT:
13375       case SECOND:
13376       case SELF:
13377       case SET:
13378       case SPACE:
13379       case SQL:
13380       case SQLCODE:
13381       case SQLERRM:
13382       case STATIC:
13383       case SUBTYPE:
13384       case SUBSTITUTABLE:
13385       case SUCCESSFUL:
13386       case SYSDATE:
13387       case SYS_REFCURSOR:
13388       case TEMPORARY:
13389       case TIME:
13390       case TIMESTAMP:
13391       case TIMEZONE_REGION:
13392       case TIMEZONE_ABBR:
13393       case TIMEZONE_MINUTE:
13394       case TIMEZONE_HOUR:
13395       case TRANSACTION:
13396       case TRUE:
13397       case TYPE:
13398       case UNDER:
13399       case USING:
13400       case YES:
13401       case SHOW:
13402       case A:
13403       case DOUBLE:
13404       case DEC:
13405       case PRECISION:
13406       case INT:
13407       case NUMERIC:
13408       case NCHAR:
13409       case NVARCHAR2:
13410       case STRING:
13411       case UROWID:
13412       case VARRAY:
13413       case VARYING:
13414       case BFILE:
13415       case BLOB:
13416       case CLOB:
13417       case NCLOB:
13418       case YEAR:
13419       case LOCAL:
13420       case ZONE:
13421       case CHARACTER:
13422       case AFTER:
13423       case BEFORE:
13424       case OLD:
13425       case PARENT:
13426       case ANALYZE:
13427       case ASSOCIATE:
13428       case AUDIT:
13429       case COMPOUND:
13430       case DATABASE:
13431       case CALL:
13432       case DDL:
13433       case DISASSOCIATE:
13434       case EACH:
13435       case FOLLOWS:
13436       case LOGOFF:
13437       case LOGON:
13438       case NESTED:
13439       case NOAUDIT:
13440       case SCHEMA:
13441       case SERVERERROR:
13442       case SHUTDOWN:
13443       case STARTUP:
13444       case STATEMENT:
13445       case STATISTICS:
13446       case SUSPEND:
13447       case TRUNCATE:
13448       case WRAPPED:
13449       case LIBRARY:
13450       case NAME:
13451       case STRUCT:
13452       case CONTEXT:
13453       case PARAMETERS:
13454       case LENGTH:
13455       case TDO:
13456       case MAXLEN:
13457       case CHARSETID:
13458       case CHARSETFORM:
13459       case ACCEPT:
13460       case ACCESSIBLE:
13461       case COPY:
13462       case DEFINE:
13463       case DISCONNECT:
13464       case HOST:
13465       case PRINT:
13466       case QUIT:
13467       case REMARK:
13468       case UNDEFINE:
13469       case VARIABLE:
13470       case WHENEVER:
13471       case ATTACH:
13472       case CAST:
13473       case TREAT:
13474       case TRIM:
13475       case LEFT:
13476       case RIGHT:
13477       case BOTH:
13478       case EMPTY:
13479       case MULTISET:
13480       case SUBMULTISET:
13481       case LEADING:
13482       case TRAILING:
13483       case CHAR_CS:
13484       case NCHAR_CS:
13485       case DBTIMEZONE:
13486       case SESSIONTIMEZONE:
13487       case AUTHENTICATED:
13488       case LINK:
13489       case SHARED:
13490       case DIRECTORY:
13491       case USER:
13492       case IDENTIFIER:
13493       case QUOTED_LITERAL:
13494         label = UnqualifiedID();
13495         break;
13496       default:
13497         jj_la1[147] = jj_gen;
13498         ;
13499       }
13500       switch (jj_nt.kind) {
13501       case WHEN:
13502         jj_consume_token(WHEN);
13503         Expression();
13504         break;
13505       default:
13506         jj_la1[148] = jj_gen;
13507         ;
13508       }
13509         jjtree.closeNodeScope(jjtn000, true);
13510         jjtc000 = false;
13511         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13512     } catch (Throwable jjte000) {
13513           if (jjtc000) {
13514             jjtree.clearNodeScope(jjtn000);
13515             jjtc000 = false;
13516           } else {
13517             jjtree.popNode();
13518           }
13519           if (jjte000 instanceof RuntimeException) {
13520             {if (true) throw (RuntimeException)jjte000;}
13521           }
13522           if (jjte000 instanceof ParseException) {
13523             {if (true) throw (ParseException)jjte000;}
13524           }
13525           {if (true) throw (Error)jjte000;}
13526     } finally {
13527           if (jjtc000) {
13528             jjtree.closeNodeScope(jjtn000, true);
13529           }
13530     }
13531     throw new Error("Missing return statement in function");
13532   }
13533 
13534   final public ASTExitStatement ExitStatement() throws ParseException {
13535  /*@bgen(jjtree) ExitStatement */
13536  ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13537  boolean jjtc000 = true;
13538  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13539     try {
13540       jj_consume_token(EXIT);
13541       switch (jj_nt.kind) {
13542       case REPLACE:
13543       case DEFINER:
13544       case CURRENT_USER:
13545       case LANGUAGE:
13546       case INLINE:
13547       case ADD:
13548       case AGGREGATE:
13549       case ARRAY:
13550       case AT:
13551       case ATTRIBUTE:
13552       case AUTHID:
13553       case BODY:
13554       case BULK:
13555       case BYTE:
13556       case CASCADE:
13557       case CLOSE:
13558       case COALESCE:
13559       case COLLECT:
13560       case COLUMN:
13561       case COMMENT:
13562       case COMMIT:
13563       case CONSTRUCTOR:
13564       case CONTINUE:
13565       case CONVERT:
13566       case CURRENT:
13567       case CURSOR:
13568       case DATA:
13569       case DAY:
13570       case DISABLE:
13571       case EDITIONABLE:
13572       case ELEMENT:
13573       case ENABLE:
13574       case ESCAPE:
13575       case EXCEPT:
13576       case EXCEPTIONS:
13577       case EXIT:
13578       case EXTERNAL:
13579       case EXTENDS:
13580       case EXTRACT:
13581       case FALSE:
13582       case FINAL:
13583       case FORCE:
13584       case FUNCTION:
13585       case GLOBAL:
13586       case HASH:
13587       case HEAP:
13588       case HOUR:
13589       case IMMEDIATE:
13590       case INDICES:
13591       case INDEXTYPE:
13592       case INDICATOR:
13593       case INSTANTIABLE:
13594       case INTERVAL:
13595       case INVALIDATE:
13596       case ISOLATION:
13597       case JAVA:
13598       case LEVEL:
13599       case LIMIT:
13600       case LOOP:
13601       case MAP:
13602       case MAX:
13603       case MEMBER:
13604       case MERGE:
13605       case MIN:
13606       case MINUTE:
13607       case MLSLABEL:
13608       case MODIFY:
13609       case MOD:
13610       case MONTH:
13611       case NATURAL:
13612       case NEW:
13613       case NO:
13614       case NONEDITIONABLE:
13615       case NULLIF:
13616       case OBJECT:
13617       case OID:
13618       case OPAQUE:
13619       case OPEN:
13620       case OPERATOR:
13621       case ORGANIZATION:
13622       case OTHERS:
13623       case OVERRIDING:
13624       case PACKAGE:
13625       case PARTITION:
13626       case PRESERVE:
13627       case PRIVATE:
13628       case PROCEDURE:
13629       case RANGE:
13630       case RAW:
13631       case REAL:
13632       case RECORD:
13633       case REF:
13634       case RELEASE:
13635       case RELIES_ON:
13636       case RENAME:
13637       case RESULT:
13638       case RETURN:
13639       case RETURNING:
13640       case REVERSE:
13641       case ROLLBACK:
13642       case ROW:
13643       case ROWS:
13644       case ROWID:
13645       case ROWNUM:
13646       case SAVE:
13647       case SAVEPOINT:
13648       case SECOND:
13649       case SELF:
13650       case SET:
13651       case SPACE:
13652       case SQL:
13653       case SQLCODE:
13654       case SQLERRM:
13655       case STATIC:
13656       case SUBTYPE:
13657       case SUBSTITUTABLE:
13658       case SUCCESSFUL:
13659       case SYSDATE:
13660       case SYS_REFCURSOR:
13661       case TEMPORARY:
13662       case TIME:
13663       case TIMESTAMP:
13664       case TIMEZONE_REGION:
13665       case TIMEZONE_ABBR:
13666       case TIMEZONE_MINUTE:
13667       case TIMEZONE_HOUR:
13668       case TRANSACTION:
13669       case TRUE:
13670       case TYPE:
13671       case UNDER:
13672       case USING:
13673       case YES:
13674       case SHOW:
13675       case A:
13676       case DOUBLE:
13677       case DEC:
13678       case PRECISION:
13679       case INT:
13680       case NUMERIC:
13681       case NCHAR:
13682       case NVARCHAR2:
13683       case STRING:
13684       case UROWID:
13685       case VARRAY:
13686       case VARYING:
13687       case BFILE:
13688       case BLOB:
13689       case CLOB:
13690       case NCLOB:
13691       case YEAR:
13692       case LOCAL:
13693       case ZONE:
13694       case CHARACTER:
13695       case AFTER:
13696       case BEFORE:
13697       case OLD:
13698       case PARENT:
13699       case ANALYZE:
13700       case ASSOCIATE:
13701       case AUDIT:
13702       case COMPOUND:
13703       case DATABASE:
13704       case CALL:
13705       case DDL:
13706       case DISASSOCIATE:
13707       case EACH:
13708       case FOLLOWS:
13709       case LOGOFF:
13710       case LOGON:
13711       case NESTED:
13712       case NOAUDIT:
13713       case SCHEMA:
13714       case SERVERERROR:
13715       case SHUTDOWN:
13716       case STARTUP:
13717       case STATEMENT:
13718       case STATISTICS:
13719       case SUSPEND:
13720       case TRUNCATE:
13721       case WRAPPED:
13722       case LIBRARY:
13723       case NAME:
13724       case STRUCT:
13725       case CONTEXT:
13726       case PARAMETERS:
13727       case LENGTH:
13728       case TDO:
13729       case MAXLEN:
13730       case CHARSETID:
13731       case CHARSETFORM:
13732       case ACCEPT:
13733       case ACCESSIBLE:
13734       case COPY:
13735       case DEFINE:
13736       case DISCONNECT:
13737       case HOST:
13738       case PRINT:
13739       case QUIT:
13740       case REMARK:
13741       case UNDEFINE:
13742       case VARIABLE:
13743       case WHENEVER:
13744       case ATTACH:
13745       case CAST:
13746       case TREAT:
13747       case TRIM:
13748       case LEFT:
13749       case RIGHT:
13750       case BOTH:
13751       case EMPTY:
13752       case MULTISET:
13753       case SUBMULTISET:
13754       case LEADING:
13755       case TRAILING:
13756       case CHAR_CS:
13757       case NCHAR_CS:
13758       case DBTIMEZONE:
13759       case SESSIONTIMEZONE:
13760       case AUTHENTICATED:
13761       case LINK:
13762       case SHARED:
13763       case DIRECTORY:
13764       case USER:
13765       case IDENTIFIER:
13766       case QUOTED_LITERAL:
13767         label = UnqualifiedID();
13768         break;
13769       default:
13770         jj_la1[149] = jj_gen;
13771         ;
13772       }
13773       switch (jj_nt.kind) {
13774       case WHEN:
13775         jj_consume_token(WHEN);
13776         Expression();
13777         break;
13778       default:
13779         jj_la1[150] = jj_gen;
13780         ;
13781       }
13782         jjtree.closeNodeScope(jjtn000, true);
13783         jjtc000 = false;
13784         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13785     } catch (Throwable jjte000) {
13786           if (jjtc000) {
13787             jjtree.clearNodeScope(jjtn000);
13788             jjtc000 = false;
13789           } else {
13790             jjtree.popNode();
13791           }
13792           if (jjte000 instanceof RuntimeException) {
13793             {if (true) throw (RuntimeException)jjte000;}
13794           }
13795           if (jjte000 instanceof ParseException) {
13796             {if (true) throw (ParseException)jjte000;}
13797           }
13798           {if (true) throw (Error)jjte000;}
13799     } finally {
13800           if (jjtc000) {
13801             jjtree.closeNodeScope(jjtn000, true);
13802           }
13803     }
13804     throw new Error("Missing return statement in function");
13805   }
13806 
13807   final public ASTRaiseStatement RaiseStatement() throws ParseException {
13808  /*@bgen(jjtree) RaiseStatement */
13809  ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13810  boolean jjtc000 = true;
13811  jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13812     try {
13813       jj_consume_token(RAISE);
13814       switch (jj_nt.kind) {
13815       case REPLACE:
13816       case DEFINER:
13817       case CURRENT_USER:
13818       case LANGUAGE:
13819       case INLINE:
13820       case ADD:
13821       case AGGREGATE:
13822       case ARRAY:
13823       case AT:
13824       case ATTRIBUTE:
13825       case AUTHID:
13826       case BODY:
13827       case BULK:
13828       case BYTE:
13829       case CASCADE:
13830       case CLOSE:
13831       case COALESCE:
13832       case COLLECT:
13833       case COLUMN:
13834       case COMMENT:
13835       case COMMIT:
13836       case CONSTRUCTOR:
13837       case CONTINUE:
13838       case CONVERT:
13839       case CURRENT:
13840       case CURSOR:
13841       case DATA:
13842       case DAY:
13843       case DISABLE:
13844       case EDITIONABLE:
13845       case ELEMENT:
13846       case ENABLE:
13847       case ESCAPE:
13848       case EXCEPT:
13849       case EXCEPTIONS:
13850       case EXIT:
13851       case EXTERNAL:
13852       case EXTENDS:
13853       case EXTRACT:
13854       case FALSE:
13855       case FINAL:
13856       case FORCE:
13857       case FUNCTION:
13858       case GLOBAL:
13859       case HASH:
13860       case HEAP:
13861       case HOUR:
13862       case IMMEDIATE:
13863       case INDICES:
13864       case INDEXTYPE:
13865       case INDICATOR:
13866       case INSTANTIABLE:
13867       case INTERVAL:
13868       case INVALIDATE:
13869       case ISOLATION:
13870       case JAVA:
13871       case LEVEL:
13872       case LIMIT:
13873       case LOOP:
13874       case MAP:
13875       case MAX:
13876       case MEMBER:
13877       case MERGE:
13878       case MIN:
13879       case MINUTE:
13880       case MLSLABEL:
13881       case MODIFY:
13882       case MOD:
13883       case MONTH:
13884       case NATURAL:
13885       case NEW:
13886       case NO:
13887       case NONEDITIONABLE:
13888       case NULLIF:
13889       case OBJECT:
13890       case OID:
13891       case OPAQUE:
13892       case OPEN:
13893       case OPERATOR:
13894       case ORGANIZATION:
13895       case OTHERS:
13896       case OVERRIDING:
13897       case PACKAGE:
13898       case PARTITION:
13899       case PRESERVE:
13900       case PRIVATE:
13901       case PROCEDURE:
13902       case RANGE:
13903       case RAW:
13904       case REAL:
13905       case RECORD:
13906       case REF:
13907       case RELEASE:
13908       case RELIES_ON:
13909       case RENAME:
13910       case RESULT:
13911       case RETURN:
13912       case RETURNING:
13913       case REVERSE:
13914       case ROLLBACK:
13915       case ROW:
13916       case ROWS:
13917       case ROWID:
13918       case ROWNUM:
13919       case SAVE:
13920       case SAVEPOINT:
13921       case SECOND:
13922       case SELF:
13923       case SET:
13924       case SPACE:
13925       case SQL:
13926       case SQLCODE:
13927       case SQLERRM:
13928       case STATIC:
13929       case SUBTYPE:
13930       case SUBSTITUTABLE:
13931       case SUCCESSFUL:
13932       case SYSDATE:
13933       case SYS_REFCURSOR:
13934       case TEMPORARY:
13935       case TIME:
13936       case TIMESTAMP:
13937       case TIMEZONE_REGION:
13938       case TIMEZONE_ABBR:
13939       case TIMEZONE_MINUTE:
13940       case TIMEZONE_HOUR:
13941       case TRANSACTION:
13942       case TRUE:
13943       case TYPE:
13944       case UNDER:
13945       case USING:
13946       case YES:
13947       case SHOW:
13948       case A:
13949       case DOUBLE:
13950       case DEC:
13951       case PRECISION:
13952       case INT:
13953       case NUMERIC:
13954       case NCHAR:
13955       case NVARCHAR2:
13956       case STRING:
13957       case UROWID:
13958       case VARRAY:
13959       case VARYING:
13960       case BFILE:
13961       case BLOB:
13962       case CLOB:
13963       case NCLOB:
13964       case YEAR:
13965       case LOCAL:
13966       case ZONE:
13967       case CHARACTER:
13968       case AFTER:
13969       case BEFORE:
13970       case OLD:
13971       case PARENT:
13972       case ANALYZE:
13973       case ASSOCIATE:
13974       case AUDIT:
13975       case COMPOUND:
13976       case DATABASE:
13977       case CALL:
13978       case DDL:
13979       case DISASSOCIATE:
13980       case EACH:
13981       case FOLLOWS:
13982       case LOGOFF:
13983       case LOGON:
13984       case NESTED:
13985       case NOAUDIT:
13986       case SCHEMA:
13987       case SERVERERROR:
13988       case SHUTDOWN:
13989       case STARTUP:
13990       case STATEMENT:
13991       case STATISTICS:
13992       case SUSPEND:
13993       case TRUNCATE:
13994       case WRAPPED:
13995       case LIBRARY:
13996       case NAME:
13997       case STRUCT:
13998       case CONTEXT:
13999       case PARAMETERS:
14000       case LENGTH:
14001       case TDO:
14002       case MAXLEN:
14003       case CHARSETID:
14004       case CHARSETFORM:
14005       case ACCEPT:
14006       case ACCESSIBLE:
14007       case COPY:
14008       case DEFINE:
14009       case DISCONNECT:
14010       case HOST:
14011       case PRINT:
14012       case QUIT:
14013       case REMARK:
14014       case UNDEFINE:
14015       case VARIABLE:
14016       case WHENEVER:
14017       case ATTACH:
14018       case CAST:
14019       case TREAT:
14020       case TRIM:
14021       case LEFT:
14022       case RIGHT:
14023       case BOTH:
14024       case EMPTY:
14025       case MULTISET:
14026       case SUBMULTISET:
14027       case LEADING:
14028       case TRAILING:
14029       case CHAR_CS:
14030       case NCHAR_CS:
14031       case DBTIMEZONE:
14032       case SESSIONTIMEZONE:
14033       case AUTHENTICATED:
14034       case LINK:
14035       case SHARED:
14036       case DIRECTORY:
14037       case USER:
14038       case IDENTIFIER:
14039       case QUOTED_LITERAL:
14040         exception = QualifiedName();
14041         break;
14042       default:
14043         jj_la1[151] = jj_gen;
14044         ;
14045       }
14046         jjtree.closeNodeScope(jjtn000, true);
14047         jjtc000 = false;
14048         if (null != exception) { jjtn000.setImage(exception.getImage()) ; }  {if (true) return jjtn000 ;}
14049     } catch (Throwable jjte000) {
14050          if (jjtc000) {
14051            jjtree.clearNodeScope(jjtn000);
14052            jjtc000 = false;
14053          } else {
14054            jjtree.popNode();
14055          }
14056          if (jjte000 instanceof RuntimeException) {
14057            {if (true) throw (RuntimeException)jjte000;}
14058          }
14059          if (jjte000 instanceof ParseException) {
14060            {if (true) throw (ParseException)jjte000;}
14061          }
14062          {if (true) throw (Error)jjte000;}
14063     } finally {
14064          if (jjtc000) {
14065            jjtree.closeNodeScope(jjtn000, true);
14066          }
14067     }
14068     throw new Error("Missing return statement in function");
14069   }
14070 
14071   final public ASTCloseStatement CloseStatement() throws ParseException {
14072  /*@bgen(jjtree) CloseStatement */
14073  ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14074  boolean jjtc000 = true;
14075  jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14076     try {
14077       jj_consume_token(CLOSE);
14078       cursor = QualifiedName();
14079         jjtree.closeNodeScope(jjtn000, true);
14080         jjtc000 = false;
14081         jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14082     } catch (Throwable jjte000) {
14083         if (jjtc000) {
14084           jjtree.clearNodeScope(jjtn000);
14085           jjtc000 = false;
14086         } else {
14087           jjtree.popNode();
14088         }
14089         if (jjte000 instanceof RuntimeException) {
14090           {if (true) throw (RuntimeException)jjte000;}
14091         }
14092         if (jjte000 instanceof ParseException) {
14093           {if (true) throw (ParseException)jjte000;}
14094         }
14095         {if (true) throw (Error)jjte000;}
14096     } finally {
14097         if (jjtc000) {
14098           jjtree.closeNodeScope(jjtn000, true);
14099         }
14100     }
14101     throw new Error("Missing return statement in function");
14102   }
14103 
14104   final public ASTOpenStatement OpenStatement() throws ParseException {
14105  /*@bgen(jjtree) OpenStatement */
14106   ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14107   boolean jjtc000 = true;
14108   jjtree.openNodeScope(jjtn000);
14109     try {
14110       jj_consume_token(OPEN);
14111       switch (jj_nt.kind) {
14112       case 5:
14113       case 16:
14114       case 17:
14115       case REPLACE:
14116       case DEFINER:
14117       case CURRENT_USER:
14118       case LANGUAGE:
14119       case INLINE:
14120       case ADD:
14121       case AGGREGATE:
14122       case ARRAY:
14123       case AT:
14124       case ATTRIBUTE:
14125       case AUTHID:
14126       case BODY:
14127       case BULK:
14128       case BYTE:
14129       case CASCADE:
14130       case CASE:
14131       case CLOSE:
14132       case COALESCE:
14133       case COLLECT:
14134       case COLUMN:
14135       case COMMENT:
14136       case COMMIT:
14137       case CONSTRUCTOR:
14138       case CONTINUE:
14139       case CONVERT:
14140       case CURRENT:
14141       case CURSOR:
14142       case DATA:
14143       case DATE:
14144       case DAY:
14145       case DISABLE:
14146       case EDITIONABLE:
14147       case ELEMENT:
14148       case ENABLE:
14149       case ESCAPE:
14150       case EXCEPT:
14151       case EXCEPTIONS:
14152       case EXIT:
14153       case EXTERNAL:
14154       case EXTENDS:
14155       case EXTRACT:
14156       case FALSE:
14157       case FINAL:
14158       case FORCE:
14159       case FUNCTION:
14160       case GLOBAL:
14161       case HASH:
14162       case HEAP:
14163       case HOUR:
14164       case IMMEDIATE:
14165       case INDICES:
14166       case INDEXTYPE:
14167       case INDICATOR:
14168       case INSTANTIABLE:
14169       case INTERVAL:
14170       case INVALIDATE:
14171       case ISOLATION:
14172       case JAVA:
14173       case LEVEL:
14174       case LIMIT:
14175       case LOOP:
14176       case MAP:
14177       case MAX:
14178       case MEMBER:
14179       case MERGE:
14180       case MIN:
14181       case MINUTE:
14182       case MLSLABEL:
14183       case MODIFY:
14184       case MOD:
14185       case MONTH:
14186       case NATURAL:
14187       case NEW:
14188       case NEW_DOT:
14189       case NO:
14190       case NONEDITIONABLE:
14191       case NOT:
14192       case NULL:
14193       case NULLIF:
14194       case OBJECT:
14195       case OID:
14196       case OPAQUE:
14197       case OPEN:
14198       case OPERATOR:
14199       case ORGANIZATION:
14200       case OTHERS:
14201       case OVERRIDING:
14202       case PACKAGE:
14203       case PARTITION:
14204       case PRESERVE:
14205       case PRIVATE:
14206       case PROCEDURE:
14207       case RANGE:
14208       case RAW:
14209       case REAL:
14210       case RECORD:
14211       case REF:
14212       case RELEASE:
14213       case RELIES_ON:
14214       case RENAME:
14215       case RESULT:
14216       case RETURN:
14217       case RETURNING:
14218       case REVERSE:
14219       case ROLLBACK:
14220       case ROW:
14221       case ROWS:
14222       case ROWID:
14223       case ROWNUM:
14224       case SAVE:
14225       case SAVEPOINT:
14226       case SECOND:
14227       case SELECT:
14228       case SELF:
14229       case SET:
14230       case SPACE:
14231       case SQL:
14232       case SQLCODE:
14233       case SQLERRM:
14234       case STATIC:
14235       case SUBTYPE:
14236       case SUBSTITUTABLE:
14237       case SUCCESSFUL:
14238       case SYSDATE:
14239       case SYS_REFCURSOR:
14240       case TEMPORARY:
14241       case TIME:
14242       case TIMESTAMP:
14243       case TIMEZONE_REGION:
14244       case TIMEZONE_ABBR:
14245       case TIMEZONE_MINUTE:
14246       case TIMEZONE_HOUR:
14247       case TRANSACTION:
14248       case TRUE:
14249       case TYPE:
14250       case UNDER:
14251       case USING:
14252       case YES:
14253       case SHOW:
14254       case A:
14255       case DOUBLE:
14256       case DEC:
14257       case PRECISION:
14258       case INT:
14259       case NUMERIC:
14260       case NCHAR:
14261       case NVARCHAR2:
14262       case STRING:
14263       case UROWID:
14264       case VARRAY:
14265       case VARYING:
14266       case BFILE:
14267       case BLOB:
14268       case CLOB:
14269       case NCLOB:
14270       case YEAR:
14271       case LOCAL:
14272       case WITH:
14273       case ZONE:
14274       case CHARACTER:
14275       case AFTER:
14276       case BEFORE:
14277       case OLD:
14278       case PARENT:
14279       case CC_IF:
14280       case ANALYZE:
14281       case ASSOCIATE:
14282       case AUDIT:
14283       case COMPOUND:
14284       case DATABASE:
14285       case CALL:
14286       case DDL:
14287       case DISASSOCIATE:
14288       case EACH:
14289       case FOLLOWS:
14290       case LOGOFF:
14291       case LOGON:
14292       case NESTED:
14293       case NOAUDIT:
14294       case SCHEMA:
14295       case SERVERERROR:
14296       case SHUTDOWN:
14297       case STARTUP:
14298       case STATEMENT:
14299       case STATISTICS:
14300       case SUSPEND:
14301       case TRUNCATE:
14302       case WRAPPED:
14303       case LIBRARY:
14304       case NAME:
14305       case STRUCT:
14306       case CONTEXT:
14307       case PARAMETERS:
14308       case LENGTH:
14309       case TDO:
14310       case MAXLEN:
14311       case CHARSETID:
14312       case CHARSETFORM:
14313       case ACCEPT:
14314       case ACCESSIBLE:
14315       case COPY:
14316       case DEFINE:
14317       case DISCONNECT:
14318       case HOST:
14319       case PRINT:
14320       case QUIT:
14321       case REMARK:
14322       case UNDEFINE:
14323       case VARIABLE:
14324       case WHENEVER:
14325       case ATTACH:
14326       case CAST:
14327       case TREAT:
14328       case TRIM:
14329       case LEFT:
14330       case RIGHT:
14331       case BOTH:
14332       case EMPTY:
14333       case MULTISET:
14334       case SUBMULTISET:
14335       case LEADING:
14336       case TRAILING:
14337       case CHAR_CS:
14338       case NCHAR_CS:
14339       case DBTIMEZONE:
14340       case SESSIONTIMEZONE:
14341       case AUTHENTICATED:
14342       case LINK:
14343       case SHARED:
14344       case DIRECTORY:
14345       case USER:
14346       case IDENTIFIER:
14347       case UNSIGNED_NUMERIC_LITERAL:
14348       case CHARACTER_LITERAL:
14349       case STRING_LITERAL:
14350       case QUOTED_LITERAL:
14351         Expression();
14352         break;
14353       default:
14354         jj_la1[152] = jj_gen;
14355         ;
14356       }
14357       switch (jj_nt.kind) {
14358       case FOR:
14359         jj_consume_token(FOR);
14360         Expression();
14361         switch (jj_nt.kind) {
14362         case USING:
14363           jj_consume_token(USING);
14364           switch (jj_nt.kind) {
14365           case IN:
14366           case IN_OUT:
14367           case OUT:
14368             switch (jj_nt.kind) {
14369             case IN:
14370               jj_consume_token(IN);
14371               break;
14372             case OUT:
14373               jj_consume_token(OUT);
14374               break;
14375             case IN_OUT:
14376               jj_consume_token(IN_OUT);
14377               break;
14378             default:
14379               jj_la1[153] = jj_gen;
14380               jj_consume_token(-1);
14381               throw new ParseException();
14382             }
14383             break;
14384           default:
14385             jj_la1[154] = jj_gen;
14386             ;
14387           }
14388           Expression();
14389           label_34:
14390           while (true) {
14391             switch (jj_nt.kind) {
14392             case 6:
14393               ;
14394               break;
14395             default:
14396               jj_la1[155] = jj_gen;
14397               break label_34;
14398             }
14399             jj_consume_token(6);
14400             switch (jj_nt.kind) {
14401             case IN:
14402             case IN_OUT:
14403             case OUT:
14404               switch (jj_nt.kind) {
14405               case IN:
14406                 jj_consume_token(IN);
14407                 break;
14408               case OUT:
14409                 jj_consume_token(OUT);
14410                 break;
14411               case IN_OUT:
14412                 jj_consume_token(IN_OUT);
14413                 break;
14414               default:
14415                 jj_la1[156] = jj_gen;
14416                 jj_consume_token(-1);
14417                 throw new ParseException();
14418               }
14419               break;
14420             default:
14421               jj_la1[157] = jj_gen;
14422               ;
14423             }
14424             Expression();
14425           }
14426           break;
14427         default:
14428           jj_la1[158] = jj_gen;
14429           ;
14430         }
14431         break;
14432       default:
14433         jj_la1[159] = jj_gen;
14434         ;
14435       }
14436         jjtree.closeNodeScope(jjtn000, true);
14437         jjtc000 = false;
14438         {if (true) return jjtn000 ;}
14439     } catch (Throwable jjte000) {
14440            if (jjtc000) {
14441              jjtree.clearNodeScope(jjtn000);
14442              jjtc000 = false;
14443            } else {
14444              jjtree.popNode();
14445            }
14446            if (jjte000 instanceof RuntimeException) {
14447              {if (true) throw (RuntimeException)jjte000;}
14448            }
14449            if (jjte000 instanceof ParseException) {
14450              {if (true) throw (ParseException)jjte000;}
14451            }
14452            {if (true) throw (Error)jjte000;}
14453     } finally {
14454            if (jjtc000) {
14455              jjtree.closeNodeScope(jjtn000, true);
14456            }
14457     }
14458     throw new Error("Missing return statement in function");
14459   }
14460 
14461   final public ASTFetchStatement FetchStatement() throws ParseException {
14462  /*@bgen(jjtree) FetchStatement */
14463   ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14464   boolean jjtc000 = true;
14465   jjtree.openNodeScope(jjtn000);
14466     try {
14467       jj_consume_token(FETCH);
14468       QualifiedName();
14469       switch (jj_nt.kind) {
14470       case BULK:
14471         jj_consume_token(BULK);
14472         jj_consume_token(COLLECT);
14473         break;
14474       default:
14475         jj_la1[160] = jj_gen;
14476         ;
14477       }
14478       jj_consume_token(INTO);
14479       Expression();
14480       label_35:
14481       while (true) {
14482         switch (jj_nt.kind) {
14483         case 6:
14484           ;
14485           break;
14486         default:
14487           jj_la1[161] = jj_gen;
14488           break label_35;
14489         }
14490         jj_consume_token(6);
14491         Expression();
14492       }
14493       switch (jj_nt.kind) {
14494       case LIMIT:
14495         jj_consume_token(LIMIT);
14496         Expression();
14497         break;
14498       default:
14499         jj_la1[162] = jj_gen;
14500         ;
14501       }
14502         jjtree.closeNodeScope(jjtn000, true);
14503         jjtc000 = false;
14504         {if (true) return jjtn000 ;}
14505     } catch (Throwable jjte000) {
14506            if (jjtc000) {
14507              jjtree.clearNodeScope(jjtn000);
14508              jjtc000 = false;
14509            } else {
14510              jjtree.popNode();
14511            }
14512            if (jjte000 instanceof RuntimeException) {
14513              {if (true) throw (RuntimeException)jjte000;}
14514            }
14515            if (jjte000 instanceof ParseException) {
14516              {if (true) throw (ParseException)jjte000;}
14517            }
14518            {if (true) throw (Error)jjte000;}
14519     } finally {
14520            if (jjtc000) {
14521              jjtree.closeNodeScope(jjtn000, true);
14522            }
14523     }
14524     throw new Error("Missing return statement in function");
14525   }
14526 
14527   final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14528  /*@bgen(jjtree) EmbeddedSqlStatement */
14529   ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14530   boolean jjtc000 = true;
14531   jjtree.openNodeScope(jjtn000);
14532     try {
14533       jj_consume_token(EXECUTE);
14534       jj_consume_token(IMMEDIATE);
14535       Expression();
14536       switch (jj_nt.kind) {
14537       case INTO:
14538         jj_consume_token(INTO);
14539         Name();
14540         label_36:
14541         while (true) {
14542           switch (jj_nt.kind) {
14543           case 6:
14544             ;
14545             break;
14546           default:
14547             jj_la1[163] = jj_gen;
14548             break label_36;
14549           }
14550           jj_consume_token(6);
14551           Name();
14552         }
14553         break;
14554       default:
14555         jj_la1[164] = jj_gen;
14556         ;
14557       }
14558       switch (jj_nt.kind) {
14559       case USING:
14560         jj_consume_token(USING);
14561         switch (jj_nt.kind) {
14562         case IN:
14563         case OUT:
14564           switch (jj_nt.kind) {
14565           case IN:
14566             jj_consume_token(IN);
14567             switch (jj_nt.kind) {
14568             case OUT:
14569               jj_consume_token(OUT);
14570               break;
14571             default:
14572               jj_la1[165] = jj_gen;
14573               ;
14574             }
14575             break;
14576           case OUT:
14577             jj_consume_token(OUT);
14578             break;
14579           default:
14580             jj_la1[166] = jj_gen;
14581             jj_consume_token(-1);
14582             throw new ParseException();
14583           }
14584           break;
14585         default:
14586           jj_la1[167] = jj_gen;
14587           ;
14588         }
14589         Expression();
14590         label_37:
14591         while (true) {
14592           switch (jj_nt.kind) {
14593           case 6:
14594             ;
14595             break;
14596           default:
14597             jj_la1[168] = jj_gen;
14598             break label_37;
14599           }
14600           jj_consume_token(6);
14601           switch (jj_nt.kind) {
14602           case IN:
14603           case OUT:
14604             switch (jj_nt.kind) {
14605             case IN:
14606               jj_consume_token(IN);
14607               switch (jj_nt.kind) {
14608               case OUT:
14609                 jj_consume_token(OUT);
14610                 break;
14611               default:
14612                 jj_la1[169] = jj_gen;
14613                 ;
14614               }
14615               break;
14616             case OUT:
14617               jj_consume_token(OUT);
14618               break;
14619             default:
14620               jj_la1[170] = jj_gen;
14621               jj_consume_token(-1);
14622               throw new ParseException();
14623             }
14624             break;
14625           default:
14626             jj_la1[171] = jj_gen;
14627             ;
14628           }
14629           Expression();
14630         }
14631         break;
14632       default:
14633         jj_la1[172] = jj_gen;
14634         ;
14635       }
14636       switch (jj_nt.kind) {
14637       case RETURN:
14638       case RETURNING:
14639         switch (jj_nt.kind) {
14640         case RETURN:
14641           jj_consume_token(RETURN);
14642           break;
14643         case RETURNING:
14644           jj_consume_token(RETURNING);
14645           break;
14646         default:
14647           jj_la1[173] = jj_gen;
14648           jj_consume_token(-1);
14649           throw new ParseException();
14650         }
14651         jj_consume_token(INTO);
14652         Expression();
14653         label_38:
14654         while (true) {
14655           switch (jj_nt.kind) {
14656           case 6:
14657             ;
14658             break;
14659           default:
14660             jj_la1[174] = jj_gen;
14661             break label_38;
14662           }
14663           jj_consume_token(6);
14664           Expression();
14665         }
14666         break;
14667       default:
14668         jj_la1[175] = jj_gen;
14669         ;
14670       }
14671       jj_consume_token(4);
14672         jjtree.closeNodeScope(jjtn000, true);
14673         jjtc000 = false;
14674         {if (true) return jjtn000 ;}
14675     } catch (Throwable jjte000) {
14676      if (jjtc000) {
14677        jjtree.clearNodeScope(jjtn000);
14678        jjtc000 = false;
14679      } else {
14680        jjtree.popNode();
14681      }
14682      if (jjte000 instanceof RuntimeException) {
14683        {if (true) throw (RuntimeException)jjte000;}
14684      }
14685      if (jjte000 instanceof ParseException) {
14686        {if (true) throw (ParseException)jjte000;}
14687      }
14688      {if (true) throw (Error)jjte000;}
14689     } finally {
14690      if (jjtc000) {
14691        jjtree.closeNodeScope(jjtn000, true);
14692      }
14693     }
14694     throw new Error("Missing return statement in function");
14695   }
14696 
14697   final public ASTPipelineStatement PipelineStatement() throws ParseException {
14698  /*@bgen(jjtree) PipelineStatement */
14699   ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14700   boolean jjtc000 = true;
14701   jjtree.openNodeScope(jjtn000);
14702     try {
14703       jj_consume_token(PIPE);
14704       jj_consume_token(ROW);
14705       Expression();
14706         jjtree.closeNodeScope(jjtn000, true);
14707         jjtc000 = false;
14708         {if (true) return jjtn000 ;}
14709     } catch (Throwable jjte000) {
14710           if (jjtc000) {
14711             jjtree.clearNodeScope(jjtn000);
14712             jjtc000 = false;
14713           } else {
14714             jjtree.popNode();
14715           }
14716           if (jjte000 instanceof RuntimeException) {
14717             {if (true) throw (RuntimeException)jjte000;}
14718           }
14719           if (jjte000 instanceof ParseException) {
14720             {if (true) throw (ParseException)jjte000;}
14721           }
14722           {if (true) throw (Error)jjte000;}
14723     } finally {
14724           if (jjtc000) {
14725             jjtree.closeNodeScope(jjtn000, true);
14726           }
14727     }
14728     throw new Error("Missing return statement in function");
14729   }
14730 
14731   final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14732  /*@bgen(jjtree) ConditionalCompilationStatement */
14733   ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14734   boolean jjtc000 = true;
14735   jjtree.openNodeScope(jjtn000);
14736     try {
14737       switch (jj_nt.kind) {
14738       case CC_IF:
14739         jj_consume_token(CC_IF);
14740         ConditionalOrExpression();
14741         jj_consume_token(CC_THEN);
14742         label_39:
14743         while (true) {
14744           switch (jj_nt.kind) {
14745           case 5:
14746           case 16:
14747           case 17:
14748           case 21:
14749           case REPLACE:
14750           case DEFINER:
14751           case CURRENT_USER:
14752           case LANGUAGE:
14753           case INLINE:
14754           case ADD:
14755           case AGGREGATE:
14756           case ARRAY:
14757           case AT:
14758           case ATTRIBUTE:
14759           case AUTHID:
14760           case BEGIN:
14761           case BODY:
14762           case BULK:
14763           case BYTE:
14764           case CASCADE:
14765           case CASE:
14766           case CLOSE:
14767           case COALESCE:
14768           case COLLECT:
14769           case COLUMN:
14770           case COMMENT:
14771           case COMMIT:
14772           case CONSTRUCTOR:
14773           case CONTINUE:
14774           case CONVERT:
14775           case CURRENT:
14776           case CURSOR:
14777           case DATA:
14778           case DATE:
14779           case DAY:
14780           case DECLARE:
14781           case DELETE:
14782           case DISABLE:
14783           case EDITIONABLE:
14784           case ELEMENT:
14785           case ENABLE:
14786           case ESCAPE:
14787           case EXCEPT:
14788           case EXCEPTIONS:
14789           case EXECUTE:
14790           case EXIT:
14791           case EXTERNAL:
14792           case EXTENDS:
14793           case EXTRACT:
14794           case FALSE:
14795           case FETCH:
14796           case FINAL:
14797           case FOR:
14798           case FORALL:
14799           case FORCE:
14800           case FUNCTION:
14801           case GLOBAL:
14802           case GOTO:
14803           case HASH:
14804           case HEAP:
14805           case HOUR:
14806           case IF:
14807           case IMMEDIATE:
14808           case INDICES:
14809           case INDEXTYPE:
14810           case INDICATOR:
14811           case INSERT:
14812           case INSTANTIABLE:
14813           case INTERVAL:
14814           case INVALIDATE:
14815           case ISOLATION:
14816           case JAVA:
14817           case LEVEL:
14818           case LIMIT:
14819           case LOCK:
14820           case LOOP:
14821           case MAP:
14822           case MAX:
14823           case MEMBER:
14824           case MERGE:
14825           case MIN:
14826           case MINUTE:
14827           case MLSLABEL:
14828           case MODIFY:
14829           case MOD:
14830           case MONTH:
14831           case NATURAL:
14832           case NEW:
14833           case NEW_DOT:
14834           case NO:
14835           case NONEDITIONABLE:
14836           case NOT:
14837           case NULL:
14838           case NULLIF:
14839           case OBJECT:
14840           case OID:
14841           case OPAQUE:
14842           case OPEN:
14843           case OPERATOR:
14844           case ORGANIZATION:
14845           case OTHERS:
14846           case OVERRIDING:
14847           case PACKAGE:
14848           case PARTITION:
14849           case PIPE:
14850           case PRAGMA:
14851           case PRESERVE:
14852           case PRIVATE:
14853           case PROCEDURE:
14854           case RAISE:
14855           case RANGE:
14856           case RAW:
14857           case REAL:
14858           case RECORD:
14859           case REF:
14860           case RELEASE:
14861           case RELIES_ON:
14862           case RENAME:
14863           case RESULT:
14864           case RETURN:
14865           case RETURNING:
14866           case REVERSE:
14867           case ROLLBACK:
14868           case ROW:
14869           case ROWS:
14870           case ROWID:
14871           case ROWNUM:
14872           case SAVE:
14873           case SAVEPOINT:
14874           case SECOND:
14875           case SELECT:
14876           case SELF:
14877           case SET:
14878           case SPACE:
14879           case SQL:
14880           case SQLCODE:
14881           case SQLERRM:
14882           case STATIC:
14883           case SUBTYPE:
14884           case SUBSTITUTABLE:
14885           case SUCCESSFUL:
14886           case SYSDATE:
14887           case SYS_REFCURSOR:
14888           case TEMPORARY:
14889           case TIME:
14890           case TIMESTAMP:
14891           case TIMEZONE_REGION:
14892           case TIMEZONE_ABBR:
14893           case TIMEZONE_MINUTE:
14894           case TIMEZONE_HOUR:
14895           case TRANSACTION:
14896           case TRUE:
14897           case TYPE:
14898           case UNDER:
14899           case USING:
14900           case WHILE:
14901           case YES:
14902           case SHOW:
14903           case A:
14904           case UPDATE:
14905           case DOUBLE:
14906           case DEC:
14907           case PRECISION:
14908           case INT:
14909           case NUMERIC:
14910           case NCHAR:
14911           case NVARCHAR2:
14912           case STRING:
14913           case UROWID:
14914           case VARRAY:
14915           case VARYING:
14916           case BFILE:
14917           case BLOB:
14918           case CLOB:
14919           case NCLOB:
14920           case YEAR:
14921           case LOCAL:
14922           case WITH:
14923           case ZONE:
14924           case CHARACTER:
14925           case AFTER:
14926           case BEFORE:
14927           case OLD:
14928           case PARENT:
14929           case CC_IF:
14930           case CC_ERROR:
14931           case ANALYZE:
14932           case ASSOCIATE:
14933           case AUDIT:
14934           case COMPOUND:
14935           case DATABASE:
14936           case CALL:
14937           case DDL:
14938           case DISASSOCIATE:
14939           case EACH:
14940           case FOLLOWS:
14941           case LOGOFF:
14942           case LOGON:
14943           case NESTED:
14944           case NOAUDIT:
14945           case SCHEMA:
14946           case SERVERERROR:
14947           case SHUTDOWN:
14948           case STARTUP:
14949           case STATEMENT:
14950           case STATISTICS:
14951           case SUSPEND:
14952           case TRUNCATE:
14953           case WRAPPED:
14954           case LIBRARY:
14955           case NAME:
14956           case STRUCT:
14957           case CONTEXT:
14958           case PARAMETERS:
14959           case LENGTH:
14960           case TDO:
14961           case MAXLEN:
14962           case CHARSETID:
14963           case CHARSETFORM:
14964           case ACCEPT:
14965           case ACCESSIBLE:
14966           case COPY:
14967           case DEFINE:
14968           case DISCONNECT:
14969           case HOST:
14970           case PRINT:
14971           case QUIT:
14972           case REMARK:
14973           case UNDEFINE:
14974           case VARIABLE:
14975           case WHENEVER:
14976           case ATTACH:
14977           case CAST:
14978           case TREAT:
14979           case TRIM:
14980           case LEFT:
14981           case RIGHT:
14982           case BOTH:
14983           case EMPTY:
14984           case MULTISET:
14985           case SUBMULTISET:
14986           case LEADING:
14987           case TRAILING:
14988           case CHAR_CS:
14989           case NCHAR_CS:
14990           case DBTIMEZONE:
14991           case SESSIONTIMEZONE:
14992           case AUTHENTICATED:
14993           case LINK:
14994           case SHARED:
14995           case DIRECTORY:
14996           case USER:
14997           case IDENTIFIER:
14998           case UNSIGNED_NUMERIC_LITERAL:
14999           case CHARACTER_LITERAL:
15000           case STRING_LITERAL:
15001           case QUOTED_LITERAL:
15002             ;
15003             break;
15004           default:
15005             jj_la1[176] = jj_gen;
15006             break label_39;
15007           }
15008           Statement();
15009         }
15010         label_40:
15011         while (true) {
15012           switch (jj_nt.kind) {
15013           case CC_ELSIF:
15014             ;
15015             break;
15016           default:
15017             jj_la1[177] = jj_gen;
15018             break label_40;
15019           }
15020           jj_consume_token(CC_ELSIF);
15021           ConditionalOrExpression();
15022           jj_consume_token(CC_THEN);
15023           label_41:
15024           while (true) {
15025             Statement();
15026             switch (jj_nt.kind) {
15027             case 5:
15028             case 16:
15029             case 17:
15030             case 21:
15031             case REPLACE:
15032             case DEFINER:
15033             case CURRENT_USER:
15034             case LANGUAGE:
15035             case INLINE:
15036             case ADD:
15037             case AGGREGATE:
15038             case ARRAY:
15039             case AT:
15040             case ATTRIBUTE:
15041             case AUTHID:
15042             case BEGIN:
15043             case BODY:
15044             case BULK:
15045             case BYTE:
15046             case CASCADE:
15047             case CASE:
15048             case CLOSE:
15049             case COALESCE:
15050             case COLLECT:
15051             case COLUMN:
15052             case COMMENT:
15053             case COMMIT:
15054             case CONSTRUCTOR:
15055             case CONTINUE:
15056             case CONVERT:
15057             case CURRENT:
15058             case CURSOR:
15059             case DATA:
15060             case DATE:
15061             case DAY:
15062             case DECLARE:
15063             case DELETE:
15064             case DISABLE:
15065             case EDITIONABLE:
15066             case ELEMENT:
15067             case ENABLE:
15068             case ESCAPE:
15069             case EXCEPT:
15070             case EXCEPTIONS:
15071             case EXECUTE:
15072             case EXIT:
15073             case EXTERNAL:
15074             case EXTENDS:
15075             case EXTRACT:
15076             case FALSE:
15077             case FETCH:
15078             case FINAL:
15079             case FOR:
15080             case FORALL:
15081             case FORCE:
15082             case FUNCTION:
15083             case GLOBAL:
15084             case GOTO:
15085             case HASH:
15086             case HEAP:
15087             case HOUR:
15088             case IF:
15089             case IMMEDIATE:
15090             case INDICES:
15091             case INDEXTYPE:
15092             case INDICATOR:
15093             case INSERT:
15094             case INSTANTIABLE:
15095             case INTERVAL:
15096             case INVALIDATE:
15097             case ISOLATION:
15098             case JAVA:
15099             case LEVEL:
15100             case LIMIT:
15101             case LOCK:
15102             case LOOP:
15103             case MAP:
15104             case MAX:
15105             case MEMBER:
15106             case MERGE:
15107             case MIN:
15108             case MINUTE:
15109             case MLSLABEL:
15110             case MODIFY:
15111             case MOD:
15112             case MONTH:
15113             case NATURAL:
15114             case NEW:
15115             case NEW_DOT:
15116             case NO:
15117             case NONEDITIONABLE:
15118             case NOT:
15119             case NULL:
15120             case NULLIF:
15121             case OBJECT:
15122             case OID:
15123             case OPAQUE:
15124             case OPEN:
15125             case OPERATOR:
15126             case ORGANIZATION:
15127             case OTHERS:
15128             case OVERRIDING:
15129             case PACKAGE:
15130             case PARTITION:
15131             case PIPE:
15132             case PRAGMA:
15133             case PRESERVE:
15134             case PRIVATE:
15135             case PROCEDURE:
15136             case RAISE:
15137             case RANGE:
15138             case RAW:
15139             case REAL:
15140             case RECORD:
15141             case REF:
15142             case RELEASE:
15143             case RELIES_ON:
15144             case RENAME:
15145             case RESULT:
15146             case RETURN:
15147             case RETURNING:
15148             case REVERSE:
15149             case ROLLBACK:
15150             case ROW:
15151             case ROWS:
15152             case ROWID:
15153             case ROWNUM:
15154             case SAVE:
15155             case SAVEPOINT:
15156             case SECOND:
15157             case SELECT:
15158             case SELF:
15159             case SET:
15160             case SPACE:
15161             case SQL:
15162             case SQLCODE:
15163             case SQLERRM:
15164             case STATIC:
15165             case SUBTYPE:
15166             case SUBSTITUTABLE:
15167             case SUCCESSFUL:
15168             case SYSDATE:
15169             case SYS_REFCURSOR:
15170             case TEMPORARY:
15171             case TIME:
15172             case TIMESTAMP:
15173             case TIMEZONE_REGION:
15174             case TIMEZONE_ABBR:
15175             case TIMEZONE_MINUTE:
15176             case TIMEZONE_HOUR:
15177             case TRANSACTION:
15178             case TRUE:
15179             case TYPE:
15180             case UNDER:
15181             case USING:
15182             case WHILE:
15183             case YES:
15184             case SHOW:
15185             case A:
15186             case UPDATE:
15187             case DOUBLE:
15188             case DEC:
15189             case PRECISION:
15190             case INT:
15191             case NUMERIC:
15192             case NCHAR:
15193             case NVARCHAR2:
15194             case STRING:
15195             case UROWID:
15196             case VARRAY:
15197             case VARYING:
15198             case BFILE:
15199             case BLOB:
15200             case CLOB:
15201             case NCLOB:
15202             case YEAR:
15203             case LOCAL:
15204             case WITH:
15205             case ZONE:
15206             case CHARACTER:
15207             case AFTER:
15208             case BEFORE:
15209             case OLD:
15210             case PARENT:
15211             case CC_IF:
15212             case CC_ERROR:
15213             case ANALYZE:
15214             case ASSOCIATE:
15215             case AUDIT:
15216             case COMPOUND:
15217             case DATABASE:
15218             case CALL:
15219             case DDL:
15220             case DISASSOCIATE:
15221             case EACH:
15222             case FOLLOWS:
15223             case LOGOFF:
15224             case LOGON:
15225             case NESTED:
15226             case NOAUDIT:
15227             case SCHEMA:
15228             case SERVERERROR:
15229             case SHUTDOWN:
15230             case STARTUP:
15231             case STATEMENT:
15232             case STATISTICS:
15233             case SUSPEND:
15234             case TRUNCATE:
15235             case WRAPPED:
15236             case LIBRARY:
15237             case NAME:
15238             case STRUCT:
15239             case CONTEXT:
15240             case PARAMETERS:
15241             case LENGTH:
15242             case TDO:
15243             case MAXLEN:
15244             case CHARSETID:
15245             case CHARSETFORM:
15246             case ACCEPT:
15247             case ACCESSIBLE:
15248             case COPY:
15249             case DEFINE:
15250             case DISCONNECT:
15251             case HOST:
15252             case PRINT:
15253             case QUIT:
15254             case REMARK:
15255             case UNDEFINE:
15256             case VARIABLE:
15257             case WHENEVER:
15258             case ATTACH:
15259             case CAST:
15260             case TREAT:
15261             case TRIM:
15262             case LEFT:
15263             case RIGHT:
15264             case BOTH:
15265             case EMPTY:
15266             case MULTISET:
15267             case SUBMULTISET:
15268             case LEADING:
15269             case TRAILING:
15270             case CHAR_CS:
15271             case NCHAR_CS:
15272             case DBTIMEZONE:
15273             case SESSIONTIMEZONE:
15274             case AUTHENTICATED:
15275             case LINK:
15276             case SHARED:
15277             case DIRECTORY:
15278             case USER:
15279             case IDENTIFIER:
15280             case UNSIGNED_NUMERIC_LITERAL:
15281             case CHARACTER_LITERAL:
15282             case STRING_LITERAL:
15283             case QUOTED_LITERAL:
15284               ;
15285               break;
15286             default:
15287               jj_la1[178] = jj_gen;
15288               break label_41;
15289             }
15290           }
15291         }
15292         label_42:
15293         while (true) {
15294           switch (jj_nt.kind) {
15295           case CC_ELSE:
15296             ;
15297             break;
15298           default:
15299             jj_la1[179] = jj_gen;
15300             break label_42;
15301           }
15302           jj_consume_token(CC_ELSE);
15303           label_43:
15304           while (true) {
15305             Statement();
15306             switch (jj_nt.kind) {
15307             case 5:
15308             case 16:
15309             case 17:
15310             case 21:
15311             case REPLACE:
15312             case DEFINER:
15313             case CURRENT_USER:
15314             case LANGUAGE:
15315             case INLINE:
15316             case ADD:
15317             case AGGREGATE:
15318             case ARRAY:
15319             case AT:
15320             case ATTRIBUTE:
15321             case AUTHID:
15322             case BEGIN:
15323             case BODY:
15324             case BULK:
15325             case BYTE:
15326             case CASCADE:
15327             case CASE:
15328             case CLOSE:
15329             case COALESCE:
15330             case COLLECT:
15331             case COLUMN:
15332             case COMMENT:
15333             case COMMIT:
15334             case CONSTRUCTOR:
15335             case CONTINUE:
15336             case CONVERT:
15337             case CURRENT:
15338             case CURSOR:
15339             case DATA:
15340             case DATE:
15341             case DAY:
15342             case DECLARE:
15343             case DELETE:
15344             case DISABLE:
15345             case EDITIONABLE:
15346             case ELEMENT:
15347             case ENABLE:
15348             case ESCAPE:
15349             case EXCEPT:
15350             case EXCEPTIONS:
15351             case EXECUTE:
15352             case EXIT:
15353             case EXTERNAL:
15354             case EXTENDS:
15355             case EXTRACT:
15356             case FALSE:
15357             case FETCH:
15358             case FINAL:
15359             case FOR:
15360             case FORALL:
15361             case FORCE:
15362             case FUNCTION:
15363             case GLOBAL:
15364             case GOTO:
15365             case HASH:
15366             case HEAP:
15367             case HOUR:
15368             case IF:
15369             case IMMEDIATE:
15370             case INDICES:
15371             case INDEXTYPE:
15372             case INDICATOR:
15373             case INSERT:
15374             case INSTANTIABLE:
15375             case INTERVAL:
15376             case INVALIDATE:
15377             case ISOLATION:
15378             case JAVA:
15379             case LEVEL:
15380             case LIMIT:
15381             case LOCK:
15382             case LOOP:
15383             case MAP:
15384             case MAX:
15385             case MEMBER:
15386             case MERGE:
15387             case MIN:
15388             case MINUTE:
15389             case MLSLABEL:
15390             case MODIFY:
15391             case MOD:
15392             case MONTH:
15393             case NATURAL:
15394             case NEW:
15395             case NEW_DOT:
15396             case NO:
15397             case NONEDITIONABLE:
15398             case NOT:
15399             case NULL:
15400             case NULLIF:
15401             case OBJECT:
15402             case OID:
15403             case OPAQUE:
15404             case OPEN:
15405             case OPERATOR:
15406             case ORGANIZATION:
15407             case OTHERS:
15408             case OVERRIDING:
15409             case PACKAGE:
15410             case PARTITION:
15411             case PIPE:
15412             case PRAGMA:
15413             case PRESERVE:
15414             case PRIVATE:
15415             case PROCEDURE:
15416             case RAISE:
15417             case RANGE:
15418             case RAW:
15419             case REAL:
15420             case RECORD:
15421             case REF:
15422             case RELEASE:
15423             case RELIES_ON:
15424             case RENAME:
15425             case RESULT:
15426             case RETURN:
15427             case RETURNING:
15428             case REVERSE:
15429             case ROLLBACK:
15430             case ROW:
15431             case ROWS:
15432             case ROWID:
15433             case ROWNUM:
15434             case SAVE:
15435             case SAVEPOINT:
15436             case SECOND:
15437             case SELECT:
15438             case SELF:
15439             case SET:
15440             case SPACE:
15441             case SQL:
15442             case SQLCODE:
15443             case SQLERRM:
15444             case STATIC:
15445             case SUBTYPE:
15446             case SUBSTITUTABLE:
15447             case SUCCESSFUL:
15448             case SYSDATE:
15449             case SYS_REFCURSOR:
15450             case TEMPORARY:
15451             case TIME:
15452             case TIMESTAMP:
15453             case TIMEZONE_REGION:
15454             case TIMEZONE_ABBR:
15455             case TIMEZONE_MINUTE:
15456             case TIMEZONE_HOUR:
15457             case TRANSACTION:
15458             case TRUE:
15459             case TYPE:
15460             case UNDER:
15461             case USING:
15462             case WHILE:
15463             case YES:
15464             case SHOW:
15465             case A:
15466             case UPDATE:
15467             case DOUBLE:
15468             case DEC:
15469             case PRECISION:
15470             case INT:
15471             case NUMERIC:
15472             case NCHAR:
15473             case NVARCHAR2:
15474             case STRING:
15475             case UROWID:
15476             case VARRAY:
15477             case VARYING:
15478             case BFILE:
15479             case BLOB:
15480             case CLOB:
15481             case NCLOB:
15482             case YEAR:
15483             case LOCAL:
15484             case WITH:
15485             case ZONE:
15486             case CHARACTER:
15487             case AFTER:
15488             case BEFORE:
15489             case OLD:
15490             case PARENT:
15491             case CC_IF:
15492             case CC_ERROR:
15493             case ANALYZE:
15494             case ASSOCIATE:
15495             case AUDIT:
15496             case COMPOUND:
15497             case DATABASE:
15498             case CALL:
15499             case DDL:
15500             case DISASSOCIATE:
15501             case EACH:
15502             case FOLLOWS:
15503             case LOGOFF:
15504             case LOGON:
15505             case NESTED:
15506             case NOAUDIT:
15507             case SCHEMA:
15508             case SERVERERROR:
15509             case SHUTDOWN:
15510             case STARTUP:
15511             case STATEMENT:
15512             case STATISTICS:
15513             case SUSPEND:
15514             case TRUNCATE:
15515             case WRAPPED:
15516             case LIBRARY:
15517             case NAME:
15518             case STRUCT:
15519             case CONTEXT:
15520             case PARAMETERS:
15521             case LENGTH:
15522             case TDO:
15523             case MAXLEN:
15524             case CHARSETID:
15525             case CHARSETFORM:
15526             case ACCEPT:
15527             case ACCESSIBLE:
15528             case COPY:
15529             case DEFINE:
15530             case DISCONNECT:
15531             case HOST:
15532             case PRINT:
15533             case QUIT:
15534             case REMARK:
15535             case UNDEFINE:
15536             case VARIABLE:
15537             case WHENEVER:
15538             case ATTACH:
15539             case CAST:
15540             case TREAT:
15541             case TRIM:
15542             case LEFT:
15543             case RIGHT:
15544             case BOTH:
15545             case EMPTY:
15546             case MULTISET:
15547             case SUBMULTISET:
15548             case LEADING:
15549             case TRAILING:
15550             case CHAR_CS:
15551             case NCHAR_CS:
15552             case DBTIMEZONE:
15553             case SESSIONTIMEZONE:
15554             case AUTHENTICATED:
15555             case LINK:
15556             case SHARED:
15557             case DIRECTORY:
15558             case USER:
15559             case IDENTIFIER:
15560             case UNSIGNED_NUMERIC_LITERAL:
15561             case CHARACTER_LITERAL:
15562             case STRING_LITERAL:
15563             case QUOTED_LITERAL:
15564               ;
15565               break;
15566             default:
15567               jj_la1[180] = jj_gen;
15568               break label_43;
15569             }
15570           }
15571         }
15572         jj_consume_token(CC_END);
15573         break;
15574       case CC_ERROR:
15575         jj_consume_token(CC_ERROR);
15576         Expression();
15577         jj_consume_token(CC_END);
15578         break;
15579       default:
15580         jj_la1[181] = jj_gen;
15581         jj_consume_token(-1);
15582         throw new ParseException();
15583       }
15584         jjtree.closeNodeScope(jjtn000, true);
15585         jjtc000 = false;
15586         {if (true) return jjtn000 ;}
15587     } catch (Throwable jjte000) {
15588           if (jjtc000) {
15589             jjtree.clearNodeScope(jjtn000);
15590             jjtc000 = false;
15591           } else {
15592             jjtree.popNode();
15593           }
15594           if (jjte000 instanceof RuntimeException) {
15595             {if (true) throw (RuntimeException)jjte000;}
15596           }
15597           if (jjte000 instanceof ParseException) {
15598             {if (true) throw (ParseException)jjte000;}
15599           }
15600           {if (true) throw (Error)jjte000;}
15601     } finally {
15602           if (jjtc000) {
15603             jjtree.closeNodeScope(jjtn000, true);
15604           }
15605     }
15606     throw new Error("Missing return statement in function");
15607   }
15608 
15609   final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15610  /*@bgen(jjtree) SubTypeDefinition */
15611         ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15612         boolean jjtc000 = true;
15613         jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15614         Token collection = null, collection2 = null;
15615         PLSQLNode name = null;
15616         PLSQLNode startElement = null, endElement = null;
15617         PLSQLNode baseType = null, returnType = null, indexBy = null ;
15618         int lastField = 0;
15619     try {
15620       switch (jj_nt.kind) {
15621       case SUBTYPE:
15622         jj_consume_token(SUBTYPE);
15623         name = QualifiedID();
15624         jj_consume_token(IS);
15625         Datatype();
15626         switch (jj_nt.kind) {
15627         case 5:
15628         case RANGE:
15629           switch (jj_nt.kind) {
15630           case 5:
15631             jj_consume_token(5);
15632             jj_consume_token(IDENTIFIER);
15633             jj_consume_token(7);
15634             break;
15635           case RANGE:
15636             jj_consume_token(RANGE);
15637             UnaryExpression(true);
15638             jj_consume_token(12);
15639             UnaryExpression(true);
15640             break;
15641           default:
15642             jj_la1[182] = jj_gen;
15643             jj_consume_token(-1);
15644             throw new ParseException();
15645           }
15646           break;
15647         default:
15648           jj_la1[183] = jj_gen;
15649           ;
15650         }
15651         switch (jj_nt.kind) {
15652         case NOT:
15653           jj_consume_token(NOT);
15654           jj_consume_token(NULL);
15655           break;
15656         default:
15657           jj_la1[184] = jj_gen;
15658           ;
15659         }
15660         break;
15661       case TYPE:
15662         jj_consume_token(TYPE);
15663         name = QualifiedID();
15664         switch (jj_nt.kind) {
15665         case IS:
15666           jj_consume_token(IS);
15667           break;
15668         case AS:
15669           jj_consume_token(AS);
15670           break;
15671         default:
15672           jj_la1[185] = jj_gen;
15673           jj_consume_token(-1);
15674           throw new ParseException();
15675         }
15676         if (jj_2_44(2)) {
15677           jj_consume_token(NEW);
15678           switch (jj_nt.kind) {
15679           case CHAR_BASE:
15680             jj_consume_token(CHAR_BASE);
15681             break;
15682           case DATE_BASE:
15683             jj_consume_token(DATE_BASE);
15684             break;
15685           case CLOB_BASE:
15686             jj_consume_token(CLOB_BASE);
15687             break;
15688           case BLOB_BASE:
15689             jj_consume_token(BLOB_BASE);
15690             break;
15691           case BFILE_BASE:
15692             jj_consume_token(BFILE_BASE);
15693             break;
15694           case NUMBER_BASE:
15695             jj_consume_token(NUMBER_BASE);
15696             break;
15697           default:
15698             jj_la1[186] = jj_gen;
15699             jj_consume_token(-1);
15700             throw new ParseException();
15701           }
15702         } else {
15703           switch (jj_nt.kind) {
15704           case OBJECT:
15705             jj_consume_token(OBJECT);
15706             jj_consume_token(5);
15707             FieldDeclaration();
15708             label_44:
15709             while (true) {
15710               switch (jj_nt.kind) {
15711               case 6:
15712                 ;
15713                 break;
15714               default:
15715                 jj_la1[187] = jj_gen;
15716                 break label_44;
15717               }
15718               jj_consume_token(6);
15719               FieldDeclaration();
15720             }
15721             jj_consume_token(7);
15722             break;
15723           case RECORD:
15724             jj_consume_token(RECORD);
15725             jj_consume_token(5);
15726             FieldDeclaration();
15727             label_45:
15728             while (true) {
15729               switch (jj_nt.kind) {
15730               case 6:
15731                 ;
15732                 break;
15733               default:
15734                 jj_la1[188] = jj_gen;
15735                 break label_45;
15736               }
15737               jj_consume_token(6);
15738               FieldDeclaration();
15739             }
15740             jj_consume_token(7);
15741             break;
15742           case TABLE:
15743           case VARRAY:
15744           case VARYING:
15745             switch (jj_nt.kind) {
15746             case TABLE:
15747               jj_consume_token(TABLE);
15748               break;
15749             case VARRAY:
15750               jj_consume_token(VARRAY);
15751               break;
15752             case VARYING:
15753               jj_consume_token(VARYING);
15754               jj_consume_token(ARRAY);
15755               break;
15756             default:
15757               jj_la1[189] = jj_gen;
15758               jj_consume_token(-1);
15759               throw new ParseException();
15760             }
15761             switch (jj_nt.kind) {
15762             case 5:
15763               jj_consume_token(5);
15764               NumericLiteral();
15765               jj_consume_token(7);
15766               break;
15767             default:
15768               jj_la1[190] = jj_gen;
15769               ;
15770             }
15771             jj_consume_token(OF);
15772             Datatype();
15773             switch (jj_nt.kind) {
15774             case NOT:
15775               jj_consume_token(NOT);
15776               jj_consume_token(NULL);
15777               break;
15778             default:
15779               jj_la1[191] = jj_gen;
15780               ;
15781             }
15782             switch (jj_nt.kind) {
15783             case INDEX:
15784               jj_consume_token(INDEX);
15785               jj_consume_token(BY);
15786               Datatype();
15787               break;
15788             default:
15789               jj_la1[192] = jj_gen;
15790               ;
15791             }
15792             break;
15793           case REF:
15794             jj_consume_token(REF);
15795             jj_consume_token(CURSOR);
15796             switch (jj_nt.kind) {
15797             case RETURN:
15798               jj_consume_token(RETURN);
15799               Datatype();
15800               break;
15801             default:
15802               jj_la1[193] = jj_gen;
15803               ;
15804             }
15805             break;
15806           case 5:
15807             jj_consume_token(5);
15808             Expression();
15809             label_46:
15810             while (true) {
15811               switch (jj_nt.kind) {
15812               case 6:
15813                 ;
15814                 break;
15815               default:
15816                 jj_la1[194] = jj_gen;
15817                 break label_46;
15818               }
15819               jj_consume_token(6);
15820               Expression();
15821             }
15822             jj_consume_token(7);
15823             break;
15824           case REPLACE:
15825           case DEFINER:
15826           case CURRENT_USER:
15827           case LANGUAGE:
15828           case INLINE:
15829           case ADD:
15830           case AGGREGATE:
15831           case ARRAY:
15832           case AT:
15833           case ATTRIBUTE:
15834           case AUTHID:
15835           case BINARY_INTEGER:
15836           case BODY:
15837           case BOOLEAN:
15838           case BULK:
15839           case BYTE:
15840           case CASCADE:
15841           case CHAR:
15842           case CHAR_BASE:
15843           case CLOSE:
15844           case COALESCE:
15845           case COLLECT:
15846           case COLUMN:
15847           case COMMENT:
15848           case COMMIT:
15849           case CONSTRUCTOR:
15850           case CONTINUE:
15851           case CONVERT:
15852           case CURRENT:
15853           case CURSOR:
15854           case DATA:
15855           case DATE:
15856           case DAY:
15857           case DECIMAL:
15858           case DISABLE:
15859           case EDITIONABLE:
15860           case ELEMENT:
15861           case ENABLE:
15862           case ESCAPE:
15863           case EXCEPT:
15864           case EXCEPTIONS:
15865           case EXIT:
15866           case EXTERNAL:
15867           case EXTENDS:
15868           case EXTRACT:
15869           case FALSE:
15870           case FINAL:
15871           case FLOAT:
15872           case FORCE:
15873           case FUNCTION:
15874           case GLOBAL:
15875           case HASH:
15876           case HEAP:
15877           case HOUR:
15878           case IMMEDIATE:
15879           case INDICES:
15880           case INDEXTYPE:
15881           case INDICATOR:
15882           case INSTANTIABLE:
15883           case INTEGER:
15884           case INTERVAL:
15885           case INVALIDATE:
15886           case ISOLATION:
15887           case JAVA:
15888           case LEVEL:
15889           case LIMIT:
15890           case LONG:
15891           case LOOP:
15892           case MAP:
15893           case MAX:
15894           case MEMBER:
15895           case MERGE:
15896           case MIN:
15897           case MINUTE:
15898           case MLSLABEL:
15899           case MODIFY:
15900           case MOD:
15901           case MONTH:
15902           case NATURAL:
15903           case NATURALN:
15904           case NEW:
15905           case NO:
15906           case NONEDITIONABLE:
15907           case NULLIF:
15908           case NUMBER:
15909           case BFILE_BASE:
15910           case BLOB_BASE:
15911           case CLOB_BASE:
15912           case DATE_BASE:
15913           case NUMBER_BASE:
15914           case OID:
15915           case OPAQUE:
15916           case OPEN:
15917           case OPERATOR:
15918           case ORGANIZATION:
15919           case OTHERS:
15920           case OVERRIDING:
15921           case PACKAGE:
15922           case PARTITION:
15923           case PLS_INTEGER:
15924           case POSITIVE:
15925           case POSITIVEN:
15926           case PRESERVE:
15927           case PRIVATE:
15928           case PROCEDURE:
15929           case RANGE:
15930           case RAW:
15931           case REAL:
15932           case RELEASE:
15933           case RELIES_ON:
15934           case RENAME:
15935           case RESULT:
15936           case RETURN:
15937           case RETURNING:
15938           case REVERSE:
15939           case ROLLBACK:
15940           case ROW:
15941           case ROWS:
15942           case ROWID:
15943           case ROWNUM:
15944           case SAVE:
15945           case SAVEPOINT:
15946           case SECOND:
15947           case SELF:
15948           case SET:
15949           case SMALLINT:
15950           case SPACE:
15951           case SQL:
15952           case SQLCODE:
15953           case SQLERRM:
15954           case STATIC:
15955           case SUBTYPE:
15956           case SUBSTITUTABLE:
15957           case SUCCESSFUL:
15958           case SYSDATE:
15959           case SYS_REFCURSOR:
15960           case TEMPORARY:
15961           case TIME:
15962           case TIMESTAMP:
15963           case TIMEZONE_REGION:
15964           case TIMEZONE_ABBR:
15965           case TIMEZONE_MINUTE:
15966           case TIMEZONE_HOUR:
15967           case TRANSACTION:
15968           case TRUE:
15969           case TYPE:
15970           case UNDER:
15971           case USING:
15972           case YES:
15973           case SHOW:
15974           case A:
15975           case VARCHAR:
15976           case VARCHAR2:
15977           case DOUBLE:
15978           case DEC:
15979           case PRECISION:
15980           case INT:
15981           case NUMERIC:
15982           case SIGNTYPE:
15983           case NCHAR:
15984           case NVARCHAR2:
15985           case STRING:
15986           case UROWID:
15987           case BFILE:
15988           case BLOB:
15989           case CLOB:
15990           case NCLOB:
15991           case YEAR:
15992           case LOCAL:
15993           case ZONE:
15994           case CHARACTER:
15995           case AFTER:
15996           case BEFORE:
15997           case OLD:
15998           case PARENT:
15999           case CC_IF:
16000           case ANALYZE:
16001           case ASSOCIATE:
16002           case AUDIT:
16003           case COMPOUND:
16004           case DATABASE:
16005           case CALL:
16006           case DDL:
16007           case DISASSOCIATE:
16008           case EACH:
16009           case FOLLOWS:
16010           case LOGOFF:
16011           case LOGON:
16012           case NESTED:
16013           case NOAUDIT:
16014           case SCHEMA:
16015           case SERVERERROR:
16016           case SHUTDOWN:
16017           case STARTUP:
16018           case STATEMENT:
16019           case STATISTICS:
16020           case SUSPEND:
16021           case TRUNCATE:
16022           case WRAPPED:
16023           case LIBRARY:
16024           case NAME:
16025           case STRUCT:
16026           case CONTEXT:
16027           case PARAMETERS:
16028           case LENGTH:
16029           case TDO:
16030           case MAXLEN:
16031           case CHARSETID:
16032           case CHARSETFORM:
16033           case ACCEPT:
16034           case ACCESSIBLE:
16035           case COPY:
16036           case DEFINE:
16037           case DISCONNECT:
16038           case HOST:
16039           case PRINT:
16040           case QUIT:
16041           case REMARK:
16042           case UNDEFINE:
16043           case VARIABLE:
16044           case WHENEVER:
16045           case ATTACH:
16046           case CAST:
16047           case TREAT:
16048           case TRIM:
16049           case LEFT:
16050           case RIGHT:
16051           case BOTH:
16052           case EMPTY:
16053           case MULTISET:
16054           case SUBMULTISET:
16055           case LEADING:
16056           case TRAILING:
16057           case CHAR_CS:
16058           case NCHAR_CS:
16059           case DBTIMEZONE:
16060           case SESSIONTIMEZONE:
16061           case AUTHENTICATED:
16062           case LINK:
16063           case SHARED:
16064           case DIRECTORY:
16065           case USER:
16066           case IDENTIFIER:
16067           case QUOTED_LITERAL:
16068             Datatype();
16069             break;
16070           default:
16071             jj_la1[195] = jj_gen;
16072             jj_consume_token(-1);
16073             throw new ParseException();
16074           }
16075         }
16076         break;
16077       default:
16078         jj_la1[196] = jj_gen;
16079         jj_consume_token(-1);
16080         throw new ParseException();
16081       }
16082       jj_consume_token(4);
16083         jjtree.closeNodeScope(jjtn000, true);
16084         jjtc000 = false;
16085         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
16086     } catch (Throwable jjte000) {
16087           if (jjtc000) {
16088             jjtree.clearNodeScope(jjtn000);
16089             jjtc000 = false;
16090           } else {
16091             jjtree.popNode();
16092           }
16093           if (jjte000 instanceof RuntimeException) {
16094             {if (true) throw (RuntimeException)jjte000;}
16095           }
16096           if (jjte000 instanceof ParseException) {
16097             {if (true) throw (ParseException)jjte000;}
16098           }
16099           {if (true) throw (Error)jjte000;}
16100     } finally {
16101           if (jjtc000) {
16102             jjtree.closeNodeScope(jjtn000, true);
16103           }
16104     }
16105     throw new Error("Missing return statement in function");
16106   }
16107 
16108   final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
16109  /*@bgen(jjtree) FieldDeclaration */
16110         ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
16111         boolean jjtc000 = true;
16112         jjtree.openNodeScope(jjtn000);PLSQLNode name;
16113         PLSQLNode dataType;
16114         PLSQLNode defaultValue = null;
16115     try {
16116       name = ID();
16117       Datatype();
16118       switch (jj_nt.kind) {
16119       case NOT:
16120       case NULL:
16121         switch (jj_nt.kind) {
16122         case NOT:
16123           jj_consume_token(NOT);
16124           break;
16125         default:
16126           jj_la1[197] = jj_gen;
16127           ;
16128         }
16129         jj_consume_token(NULL);
16130         break;
16131       default:
16132         jj_la1[198] = jj_gen;
16133         ;
16134       }
16135       switch (jj_nt.kind) {
16136       case 9:
16137       case _DEFAULT:
16138         switch (jj_nt.kind) {
16139         case 9:
16140           jj_consume_token(9);
16141           jj_consume_token(10);
16142           break;
16143         case _DEFAULT:
16144           jj_consume_token(_DEFAULT);
16145           break;
16146         default:
16147           jj_la1[199] = jj_gen;
16148           jj_consume_token(-1);
16149           throw new ParseException();
16150         }
16151         Expression();
16152         break;
16153       default:
16154         jj_la1[200] = jj_gen;
16155         ;
16156       }
16157         jjtree.closeNodeScope(jjtn000, true);
16158         jjtc000 = false;
16159         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
16160     } catch (Throwable jjte000) {
16161           if (jjtc000) {
16162             jjtree.clearNodeScope(jjtn000);
16163             jjtc000 = false;
16164           } else {
16165             jjtree.popNode();
16166           }
16167           if (jjte000 instanceof RuntimeException) {
16168             {if (true) throw (RuntimeException)jjte000;}
16169           }
16170           if (jjte000 instanceof ParseException) {
16171             {if (true) throw (ParseException)jjte000;}
16172           }
16173           {if (true) throw (Error)jjte000;}
16174     } finally {
16175           if (jjtc000) {
16176             jjtree.closeNodeScope(jjtn000, true);
16177           }
16178     }
16179     throw new Error("Missing return statement in function");
16180   }
16181 
16182   final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16183                                                           /*@bgen(jjtree) CollectionTypeDefinition */
16184                                                           ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16185                                                           boolean jjtc000 = true;
16186                                                           jjtree.openNodeScope(jjtn000);Token t = null ;
16187     try {
16188       t = jj_consume_token(IDENTIFIER);
16189                                                                                                   jjtree.closeNodeScope(jjtn000, true);
16190                                                                                                   jjtc000 = false;
16191                                                                                                   jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16192     } finally {
16193                                                                                  if (jjtc000) {
16194                                                                                    jjtree.closeNodeScope(jjtn000, true);
16195                                                                                  }
16196     }
16197     throw new Error("Missing return statement in function");
16198   }
16199 
16200   final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16201                                                     /*@bgen(jjtree) CollectionDeclaration */
16202                                                     ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16203                                                     boolean jjtc000 = true;
16204                                                     jjtree.openNodeScope(jjtn000);Token t = null ;
16205     try {
16206       t = jj_consume_token(IDENTIFIER);
16207                                                                                             jjtree.closeNodeScope(jjtn000, true);
16208                                                                                             jjtc000 = false;
16209                                                                                             jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16210     } finally {
16211                                                                            if (jjtc000) {
16212                                                                              jjtree.closeNodeScope(jjtn000, true);
16213                                                                            }
16214     }
16215     throw new Error("Missing return statement in function");
16216   }
16217 
16218   final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16219                                             /*@bgen(jjtree) ObjectDeclaration */
16220                                             ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16221                                             boolean jjtc000 = true;
16222                                             jjtree.openNodeScope(jjtn000);Token t = null ;
16223     try {
16224       t = jj_consume_token(IDENTIFIER);
16225                                                                                     jjtree.closeNodeScope(jjtn000, true);
16226                                                                                     jjtc000 = false;
16227                                                                                     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16228     } finally {
16229                                                                    if (jjtc000) {
16230                                                                      jjtree.closeNodeScope(jjtn000, true);
16231                                                                    }
16232     }
16233     throw new Error("Missing return statement in function");
16234   }
16235 
16236 /** Java stored procedure, external function*/
16237   final public ASTCallSpecTail CallSpecTail() throws ParseException {
16238                                   /*@bgen(jjtree) CallSpecTail */
16239   ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16240   boolean jjtc000 = true;
16241   jjtree.openNodeScope(jjtn000);
16242     try {
16243       switch (jj_nt.kind) {
16244       case EXTERNAL:
16245         jj_consume_token(EXTERNAL);
16246         break;
16247       case LANGUAGE:
16248         jj_consume_token(LANGUAGE);
16249         switch (jj_nt.kind) {
16250         case IDENTIFIER:
16251           jj_consume_token(IDENTIFIER);
16252           break;
16253         case JAVA:
16254           jj_consume_token(JAVA);
16255           break;
16256         default:
16257           jj_la1[201] = jj_gen;
16258           jj_consume_token(-1);
16259           throw new ParseException();
16260         }
16261         break;
16262       default:
16263         jj_la1[202] = jj_gen;
16264         jj_consume_token(-1);
16265         throw new ParseException();
16266       }
16267       label_47:
16268       while (true) {
16269         switch (jj_nt.kind) {
16270         case WITH:
16271         case LIBRARY:
16272         case NAME:
16273         case PARAMETERS:
16274           ;
16275           break;
16276         default:
16277           jj_la1[203] = jj_gen;
16278           break label_47;
16279         }
16280         switch (jj_nt.kind) {
16281         case LIBRARY:
16282           jj_consume_token(LIBRARY);
16283           switch (jj_nt.kind) {
16284           case IDENTIFIER:
16285             jj_consume_token(IDENTIFIER);
16286             break;
16287           case QUOTED_LITERAL:
16288             jj_consume_token(QUOTED_LITERAL);
16289             break;
16290           case STRING_LITERAL:
16291             StringLiteral();
16292             break;
16293           default:
16294             jj_la1[204] = jj_gen;
16295             jj_consume_token(-1);
16296             throw new ParseException();
16297           }
16298           switch (jj_nt.kind) {
16299           case 3:
16300             jj_consume_token(3);
16301             switch (jj_nt.kind) {
16302             case IDENTIFIER:
16303               jj_consume_token(IDENTIFIER);
16304               break;
16305             case QUOTED_LITERAL:
16306               jj_consume_token(QUOTED_LITERAL);
16307               break;
16308             case STRING_LITERAL:
16309               StringLiteral();
16310               break;
16311             default:
16312               jj_la1[205] = jj_gen;
16313               jj_consume_token(-1);
16314               throw new ParseException();
16315             }
16316             break;
16317           default:
16318             jj_la1[206] = jj_gen;
16319             ;
16320           }
16321           break;
16322         case NAME:
16323           jj_consume_token(NAME);
16324           switch (jj_nt.kind) {
16325           case IDENTIFIER:
16326             jj_consume_token(IDENTIFIER);
16327             break;
16328           case QUOTED_LITERAL:
16329             jj_consume_token(QUOTED_LITERAL);
16330             break;
16331           case STRING_LITERAL:
16332             StringLiteral();
16333             break;
16334           default:
16335             jj_la1[207] = jj_gen;
16336             jj_consume_token(-1);
16337             throw new ParseException();
16338           }
16339           break;
16340         case WITH:
16341           jj_consume_token(WITH);
16342           jj_consume_token(CONTEXT);
16343           break;
16344         case PARAMETERS:
16345           jj_consume_token(PARAMETERS);
16346           SkipPastNextOccurrence(")");
16347           break;
16348         default:
16349           jj_la1[208] = jj_gen;
16350           jj_consume_token(-1);
16351           throw new ParseException();
16352         }
16353       }
16354         jjtree.closeNodeScope(jjtn000, true);
16355         jjtc000 = false;
16356         {if (true) return jjtn000 ;}
16357     } catch (Throwable jjte000) {
16358           if (jjtc000) {
16359             jjtree.clearNodeScope(jjtn000);
16360             jjtc000 = false;
16361           } else {
16362             jjtree.popNode();
16363           }
16364           if (jjte000 instanceof RuntimeException) {
16365             {if (true) throw (RuntimeException)jjte000;}
16366           }
16367           if (jjte000 instanceof ParseException) {
16368             {if (true) throw (ParseException)jjte000;}
16369           }
16370           {if (true) throw (Error)jjte000;}
16371     } finally {
16372           if (jjtc000) {
16373             jjtree.closeNodeScope(jjtn000, true);
16374           }
16375     }
16376     throw new Error("Missing return statement in function");
16377   }
16378 
16379 /** Cursor (common part of specification and body) */
16380   final public ASTCursorUnit CursorUnit() throws ParseException {
16381  /*@bgen(jjtree) CursorUnit */
16382  ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16383  boolean jjtc000 = true;
16384  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16385     try {
16386       jj_consume_token(CURSOR);
16387       simpleNode = ID();
16388       switch (jj_nt.kind) {
16389       case 5:
16390         FormalParameters();
16391         break;
16392       default:
16393         jj_la1[209] = jj_gen;
16394         ;
16395       }
16396       switch (jj_nt.kind) {
16397       case RETURN:
16398         jj_consume_token(RETURN);
16399         Datatype();
16400         break;
16401       default:
16402         jj_la1[210] = jj_gen;
16403         ;
16404       }
16405       switch (jj_nt.kind) {
16406       case IS:
16407         jj_consume_token(IS);
16408         label_48:
16409         while (true) {
16410           switch (jj_nt.kind) {
16411           case 5:
16412             ;
16413             break;
16414           default:
16415             jj_la1[211] = jj_gen;
16416             break label_48;
16417           }
16418           jj_consume_token(5);
16419         }
16420         SqlStatement(null,";");
16421         break;
16422       default:
16423         jj_la1[212] = jj_gen;
16424         ;
16425       }
16426       jj_consume_token(4);
16427         jjtree.closeNodeScope(jjtn000, true);
16428         jjtc000 = false;
16429         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
16430     } catch (Throwable jjte000) {
16431           if (jjtc000) {
16432             jjtree.clearNodeScope(jjtn000);
16433             jjtc000 = false;
16434           } else {
16435             jjtree.popNode();
16436           }
16437           if (jjte000 instanceof RuntimeException) {
16438             {if (true) throw (RuntimeException)jjte000;}
16439           }
16440           if (jjte000 instanceof ParseException) {
16441             {if (true) throw (ParseException)jjte000;}
16442           }
16443           {if (true) throw (Error)jjte000;}
16444     } finally {
16445           if (jjtc000) {
16446             jjtree.closeNodeScope(jjtn000, true);
16447           }
16448     }
16449     throw new Error("Missing return statement in function");
16450   }
16451 
16452   final public ASTCursorSpecification CursorSpecification() throws ParseException {
16453                                                  /*@bgen(jjtree) CursorSpecification */
16454   ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16455   boolean jjtc000 = true;
16456   jjtree.openNodeScope(jjtn000);
16457     try {
16458       CursorUnit();
16459         jjtree.closeNodeScope(jjtn000, true);
16460         jjtc000 = false;
16461         {if (true) return jjtn000 ;}
16462     } catch (Throwable jjte000) {
16463           if (jjtc000) {
16464             jjtree.clearNodeScope(jjtn000);
16465             jjtc000 = false;
16466           } else {
16467             jjtree.popNode();
16468           }
16469           if (jjte000 instanceof RuntimeException) {
16470             {if (true) throw (RuntimeException)jjte000;}
16471           }
16472           if (jjte000 instanceof ParseException) {
16473             {if (true) throw (ParseException)jjte000;}
16474           }
16475           {if (true) throw (Error)jjte000;}
16476     } finally {
16477           if (jjtc000) {
16478             jjtree.closeNodeScope(jjtn000, true);
16479           }
16480     }
16481     throw new Error("Missing return statement in function");
16482   }
16483 
16484   final public ASTCursorBody CursorBody() throws ParseException {
16485                                /*@bgen(jjtree) CursorBody */
16486   ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16487   boolean jjtc000 = true;
16488   jjtree.openNodeScope(jjtn000);
16489     try {
16490       CursorUnit();
16491         jjtree.closeNodeScope(jjtn000, true);
16492         jjtc000 = false;
16493         {if (true) return jjtn000 ;}
16494     } catch (Throwable jjte000) {
16495           if (jjtc000) {
16496             jjtree.clearNodeScope(jjtn000);
16497             jjtc000 = false;
16498           } else {
16499             jjtree.popNode();
16500           }
16501           if (jjte000 instanceof RuntimeException) {
16502             {if (true) throw (RuntimeException)jjte000;}
16503           }
16504           if (jjte000 instanceof ParseException) {
16505             {if (true) throw (ParseException)jjte000;}
16506           }
16507           {if (true) throw (Error)jjte000;}
16508     } finally {
16509           if (jjtc000) {
16510             jjtree.closeNodeScope(jjtn000, true);
16511           }
16512     }
16513     throw new Error("Missing return statement in function");
16514   }
16515 
16516 // ============================================================================
16517 // E X P R E S S I O N S
16518 // ============================================================================
16519 
16520 /*
16521 String expression() :
16522 {}
16523 {
16524 	"test"
16525 	{ return ""; }
16526 }
16527 */
16528   final public ASTExpression Expression() throws ParseException {
16529  /*@bgen(jjtree) Expression */
16530   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16531   boolean jjtc000 = true;
16532   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16533   StringBuilder sb = new StringBuilder() ;
16534     try {
16535       if (jj_2_45(2147483647)) {
16536         simpleNode = Assignment();
16537                                                                               sb.append(simpleNode.getImage());
16538       } else {
16539         switch (jj_nt.kind) {
16540         case 5:
16541         case 16:
16542         case 17:
16543         case REPLACE:
16544         case DEFINER:
16545         case CURRENT_USER:
16546         case LANGUAGE:
16547         case INLINE:
16548         case ADD:
16549         case AGGREGATE:
16550         case ARRAY:
16551         case AT:
16552         case ATTRIBUTE:
16553         case AUTHID:
16554         case BODY:
16555         case BULK:
16556         case BYTE:
16557         case CASCADE:
16558         case CASE:
16559         case CLOSE:
16560         case COALESCE:
16561         case COLLECT:
16562         case COLUMN:
16563         case COMMENT:
16564         case COMMIT:
16565         case CONSTRUCTOR:
16566         case CONTINUE:
16567         case CONVERT:
16568         case CURRENT:
16569         case CURSOR:
16570         case DATA:
16571         case DATE:
16572         case DAY:
16573         case DISABLE:
16574         case EDITIONABLE:
16575         case ELEMENT:
16576         case ENABLE:
16577         case ESCAPE:
16578         case EXCEPT:
16579         case EXCEPTIONS:
16580         case EXIT:
16581         case EXTERNAL:
16582         case EXTENDS:
16583         case EXTRACT:
16584         case FALSE:
16585         case FINAL:
16586         case FORCE:
16587         case FUNCTION:
16588         case GLOBAL:
16589         case HASH:
16590         case HEAP:
16591         case HOUR:
16592         case IMMEDIATE:
16593         case INDICES:
16594         case INDEXTYPE:
16595         case INDICATOR:
16596         case INSTANTIABLE:
16597         case INTERVAL:
16598         case INVALIDATE:
16599         case ISOLATION:
16600         case JAVA:
16601         case LEVEL:
16602         case LIMIT:
16603         case LOOP:
16604         case MAP:
16605         case MAX:
16606         case MEMBER:
16607         case MERGE:
16608         case MIN:
16609         case MINUTE:
16610         case MLSLABEL:
16611         case MODIFY:
16612         case MOD:
16613         case MONTH:
16614         case NATURAL:
16615         case NEW:
16616         case NEW_DOT:
16617         case NO:
16618         case NONEDITIONABLE:
16619         case NOT:
16620         case NULL:
16621         case NULLIF:
16622         case OBJECT:
16623         case OID:
16624         case OPAQUE:
16625         case OPEN:
16626         case OPERATOR:
16627         case ORGANIZATION:
16628         case OTHERS:
16629         case OVERRIDING:
16630         case PACKAGE:
16631         case PARTITION:
16632         case PRESERVE:
16633         case PRIVATE:
16634         case PROCEDURE:
16635         case RANGE:
16636         case RAW:
16637         case REAL:
16638         case RECORD:
16639         case REF:
16640         case RELEASE:
16641         case RELIES_ON:
16642         case RENAME:
16643         case RESULT:
16644         case RETURN:
16645         case RETURNING:
16646         case REVERSE:
16647         case ROLLBACK:
16648         case ROW:
16649         case ROWS:
16650         case ROWID:
16651         case ROWNUM:
16652         case SAVE:
16653         case SAVEPOINT:
16654         case SECOND:
16655         case SELECT:
16656         case SELF:
16657         case SET:
16658         case SPACE:
16659         case SQL:
16660         case SQLCODE:
16661         case SQLERRM:
16662         case STATIC:
16663         case SUBTYPE:
16664         case SUBSTITUTABLE:
16665         case SUCCESSFUL:
16666         case SYSDATE:
16667         case SYS_REFCURSOR:
16668         case TEMPORARY:
16669         case TIME:
16670         case TIMESTAMP:
16671         case TIMEZONE_REGION:
16672         case TIMEZONE_ABBR:
16673         case TIMEZONE_MINUTE:
16674         case TIMEZONE_HOUR:
16675         case TRANSACTION:
16676         case TRUE:
16677         case TYPE:
16678         case UNDER:
16679         case USING:
16680         case YES:
16681         case SHOW:
16682         case A:
16683         case DOUBLE:
16684         case DEC:
16685         case PRECISION:
16686         case INT:
16687         case NUMERIC:
16688         case NCHAR:
16689         case NVARCHAR2:
16690         case STRING:
16691         case UROWID:
16692         case VARRAY:
16693         case VARYING:
16694         case BFILE:
16695         case BLOB:
16696         case CLOB:
16697         case NCLOB:
16698         case YEAR:
16699         case LOCAL:
16700         case WITH:
16701         case ZONE:
16702         case CHARACTER:
16703         case AFTER:
16704         case BEFORE:
16705         case OLD:
16706         case PARENT:
16707         case ANALYZE:
16708         case ASSOCIATE:
16709         case AUDIT:
16710         case COMPOUND:
16711         case DATABASE:
16712         case CALL:
16713         case DDL:
16714         case DISASSOCIATE:
16715         case EACH:
16716         case FOLLOWS:
16717         case LOGOFF:
16718         case LOGON:
16719         case NESTED:
16720         case NOAUDIT:
16721         case SCHEMA:
16722         case SERVERERROR:
16723         case SHUTDOWN:
16724         case STARTUP:
16725         case STATEMENT:
16726         case STATISTICS:
16727         case SUSPEND:
16728         case TRUNCATE:
16729         case WRAPPED:
16730         case LIBRARY:
16731         case NAME:
16732         case STRUCT:
16733         case CONTEXT:
16734         case PARAMETERS:
16735         case LENGTH:
16736         case TDO:
16737         case MAXLEN:
16738         case CHARSETID:
16739         case CHARSETFORM:
16740         case ACCEPT:
16741         case ACCESSIBLE:
16742         case COPY:
16743         case DEFINE:
16744         case DISCONNECT:
16745         case HOST:
16746         case PRINT:
16747         case QUIT:
16748         case REMARK:
16749         case UNDEFINE:
16750         case VARIABLE:
16751         case WHENEVER:
16752         case ATTACH:
16753         case CAST:
16754         case TREAT:
16755         case TRIM:
16756         case LEFT:
16757         case RIGHT:
16758         case BOTH:
16759         case EMPTY:
16760         case MULTISET:
16761         case SUBMULTISET:
16762         case LEADING:
16763         case TRAILING:
16764         case CHAR_CS:
16765         case NCHAR_CS:
16766         case DBTIMEZONE:
16767         case SESSIONTIMEZONE:
16768         case AUTHENTICATED:
16769         case LINK:
16770         case SHARED:
16771         case DIRECTORY:
16772         case USER:
16773         case IDENTIFIER:
16774         case UNSIGNED_NUMERIC_LITERAL:
16775         case CHARACTER_LITERAL:
16776         case STRING_LITERAL:
16777         case QUOTED_LITERAL:
16778           simpleNode = ConditionalOrExpression();
16779                                                       sb.append(simpleNode.getImage());
16780           break;
16781         case CC_IF:
16782           simpleNode = CompilationExpression();
16783                                                     sb.append(simpleNode.getImage());
16784           break;
16785         default:
16786           jj_la1[213] = jj_gen;
16787           jj_consume_token(-1);
16788           throw new ParseException();
16789         }
16790       }
16791    jjtree.closeNodeScope(jjtn000, true);
16792    jjtc000 = false;
16793  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16794     } catch (Throwable jjte000) {
16795           if (jjtc000) {
16796             jjtree.clearNodeScope(jjtn000);
16797             jjtc000 = false;
16798           } else {
16799             jjtree.popNode();
16800           }
16801           if (jjte000 instanceof RuntimeException) {
16802             {if (true) throw (RuntimeException)jjte000;}
16803           }
16804           if (jjte000 instanceof ParseException) {
16805             {if (true) throw (ParseException)jjte000;}
16806           }
16807           {if (true) throw (Error)jjte000;}
16808     } finally {
16809           if (jjtc000) {
16810             jjtree.closeNodeScope(jjtn000, true);
16811           }
16812     }
16813     throw new Error("Missing return statement in function");
16814   }
16815 
16816   final public ASTCompilationExpression CompilationExpression() throws ParseException {
16817  /*@bgen(jjtree) CompilationExpression */
16818   ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16819   boolean jjtc000 = true;
16820   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16821   StringBuilder sb = new StringBuilder() ;
16822     try {
16823       jj_consume_token(CC_IF);
16824                    sb.append(" "); sb.append(token.image) ;
16825       simpleNode = ConditionalOrExpression();
16826                                                    sb.append(" "); sb.append(simpleNode.getImage());
16827       jj_consume_token(CC_THEN);
16828                      sb.append(" "); sb.append(token.image);
16829       simpleNode = Expression();
16830                                      sb.append(" "); sb.append(simpleNode.getImage());
16831       label_49:
16832       while (true) {
16833         switch (jj_nt.kind) {
16834         case CC_ELSIF:
16835           ;
16836           break;
16837         default:
16838           jj_la1[214] = jj_gen;
16839           break label_49;
16840         }
16841         jj_consume_token(CC_ELSIF);
16842                         sb.append(" "); sb.append(token.image);
16843         simpleNode = ConditionalOrExpression();
16844                                                     sb.append(" "); sb.append(simpleNode.getImage());
16845         jj_consume_token(CC_THEN);
16846                        sb.append(" "); sb.append(token.image);
16847         simpleNode = Expression();
16848                                        sb.append(" "); sb.append(simpleNode.getImage());
16849       }
16850       label_50:
16851       while (true) {
16852         switch (jj_nt.kind) {
16853         case CC_ELSE:
16854           ;
16855           break;
16856         default:
16857           jj_la1[215] = jj_gen;
16858           break label_50;
16859         }
16860         jj_consume_token(CC_ELSE);
16861                        sb.append(" "); sb.append(token.image);
16862         simpleNode = Expression();
16863                                         sb.append(" "); sb.append(simpleNode.getImage());
16864       }
16865       jj_consume_token(CC_END);
16866                     sb.append(" "); sb.append(token.image);
16867    jjtree.closeNodeScope(jjtn000, true);
16868    jjtc000 = false;
16869  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16870     } catch (Throwable jjte000) {
16871           if (jjtc000) {
16872             jjtree.clearNodeScope(jjtn000);
16873             jjtc000 = false;
16874           } else {
16875             jjtree.popNode();
16876           }
16877           if (jjte000 instanceof RuntimeException) {
16878             {if (true) throw (RuntimeException)jjte000;}
16879           }
16880           if (jjte000 instanceof ParseException) {
16881             {if (true) throw (ParseException)jjte000;}
16882           }
16883           {if (true) throw (Error)jjte000;}
16884     } finally {
16885           if (jjtc000) {
16886             jjtree.closeNodeScope(jjtn000, true);
16887           }
16888     }
16889     throw new Error("Missing return statement in function");
16890   }
16891 
16892   final public ASTAssignment Assignment() throws ParseException {
16893  /*@bgen(jjtree) Assignment */
16894   ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16895   boolean jjtc000 = true;
16896   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16897     try {
16898       simpleNode = PrimaryExpression();
16899                                        sb.append(simpleNode.getImage());
16900       jj_consume_token(9);
16901       jj_consume_token(10);
16902                sb.append(" := ");
16903       simpleNode = Expression();
16904                                sb.append(simpleNode.getImage());
16905    jjtree.closeNodeScope(jjtn000, true);
16906    jjtc000 = false;
16907  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16908     } catch (Throwable jjte000) {
16909     if (jjtc000) {
16910       jjtree.clearNodeScope(jjtn000);
16911       jjtc000 = false;
16912     } else {
16913       jjtree.popNode();
16914     }
16915     if (jjte000 instanceof RuntimeException) {
16916       {if (true) throw (RuntimeException)jjte000;}
16917     }
16918     if (jjte000 instanceof ParseException) {
16919       {if (true) throw (ParseException)jjte000;}
16920     }
16921     {if (true) throw (Error)jjte000;}
16922     } finally {
16923     if (jjtc000) {
16924       jjtree.closeNodeScope(jjtn000, true);
16925     }
16926     }
16927     throw new Error("Missing return statement in function");
16928   }
16929 
16930   final public ASTCaseExpression CaseExpression() throws ParseException {
16931  /*@bgen(jjtree) CaseExpression */
16932   ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16933   boolean jjtc000 = true;
16934   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16935     try {
16936       thisToken = jj_consume_token(CASE);
16937                              sb.append(thisToken.image);
16938       switch (jj_nt.kind) {
16939       case 5:
16940       case 16:
16941       case 17:
16942       case REPLACE:
16943       case DEFINER:
16944       case CURRENT_USER:
16945       case LANGUAGE:
16946       case INLINE:
16947       case ADD:
16948       case AGGREGATE:
16949       case ARRAY:
16950       case AT:
16951       case ATTRIBUTE:
16952       case AUTHID:
16953       case BODY:
16954       case BULK:
16955       case BYTE:
16956       case CASCADE:
16957       case CASE:
16958       case CLOSE:
16959       case COALESCE:
16960       case COLLECT:
16961       case COLUMN:
16962       case COMMENT:
16963       case COMMIT:
16964       case CONSTRUCTOR:
16965       case CONTINUE:
16966       case CONVERT:
16967       case CURRENT:
16968       case CURSOR:
16969       case DATA:
16970       case DATE:
16971       case DAY:
16972       case DISABLE:
16973       case EDITIONABLE:
16974       case ELEMENT:
16975       case ENABLE:
16976       case ESCAPE:
16977       case EXCEPT:
16978       case EXCEPTIONS:
16979       case EXIT:
16980       case EXTERNAL:
16981       case EXTENDS:
16982       case EXTRACT:
16983       case FALSE:
16984       case FINAL:
16985       case FORCE:
16986       case FUNCTION:
16987       case GLOBAL:
16988       case HASH:
16989       case HEAP:
16990       case HOUR:
16991       case IMMEDIATE:
16992       case INDICES:
16993       case INDEXTYPE:
16994       case INDICATOR:
16995       case INSTANTIABLE:
16996       case INTERVAL:
16997       case INVALIDATE:
16998       case ISOLATION:
16999       case JAVA:
17000       case LEVEL:
17001       case LIMIT:
17002       case LOOP:
17003       case MAP:
17004       case MAX:
17005       case MEMBER:
17006       case MERGE:
17007       case MIN:
17008       case MINUTE:
17009       case MLSLABEL:
17010       case MODIFY:
17011       case MOD:
17012       case MONTH:
17013       case NATURAL:
17014       case NEW:
17015       case NEW_DOT:
17016       case NO:
17017       case NONEDITIONABLE:
17018       case NOT:
17019       case NULL:
17020       case NULLIF:
17021       case OBJECT:
17022       case OID:
17023       case OPAQUE:
17024       case OPEN:
17025       case OPERATOR:
17026       case ORGANIZATION:
17027       case OTHERS:
17028       case OVERRIDING:
17029       case PACKAGE:
17030       case PARTITION:
17031       case PRESERVE:
17032       case PRIVATE:
17033       case PROCEDURE:
17034       case RANGE:
17035       case RAW:
17036       case REAL:
17037       case RECORD:
17038       case REF:
17039       case RELEASE:
17040       case RELIES_ON:
17041       case RENAME:
17042       case RESULT:
17043       case RETURN:
17044       case RETURNING:
17045       case REVERSE:
17046       case ROLLBACK:
17047       case ROW:
17048       case ROWS:
17049       case ROWID:
17050       case ROWNUM:
17051       case SAVE:
17052       case SAVEPOINT:
17053       case SECOND:
17054       case SELECT:
17055       case SELF:
17056       case SET:
17057       case SPACE:
17058       case SQL:
17059       case SQLCODE:
17060       case SQLERRM:
17061       case STATIC:
17062       case SUBTYPE:
17063       case SUBSTITUTABLE:
17064       case SUCCESSFUL:
17065       case SYSDATE:
17066       case SYS_REFCURSOR:
17067       case TEMPORARY:
17068       case TIME:
17069       case TIMESTAMP:
17070       case TIMEZONE_REGION:
17071       case TIMEZONE_ABBR:
17072       case TIMEZONE_MINUTE:
17073       case TIMEZONE_HOUR:
17074       case TRANSACTION:
17075       case TRUE:
17076       case TYPE:
17077       case UNDER:
17078       case USING:
17079       case YES:
17080       case SHOW:
17081       case A:
17082       case DOUBLE:
17083       case DEC:
17084       case PRECISION:
17085       case INT:
17086       case NUMERIC:
17087       case NCHAR:
17088       case NVARCHAR2:
17089       case STRING:
17090       case UROWID:
17091       case VARRAY:
17092       case VARYING:
17093       case BFILE:
17094       case BLOB:
17095       case CLOB:
17096       case NCLOB:
17097       case YEAR:
17098       case LOCAL:
17099       case WITH:
17100       case ZONE:
17101       case CHARACTER:
17102       case AFTER:
17103       case BEFORE:
17104       case OLD:
17105       case PARENT:
17106       case CC_IF:
17107       case ANALYZE:
17108       case ASSOCIATE:
17109       case AUDIT:
17110       case COMPOUND:
17111       case DATABASE:
17112       case CALL:
17113       case DDL:
17114       case DISASSOCIATE:
17115       case EACH:
17116       case FOLLOWS:
17117       case LOGOFF:
17118       case LOGON:
17119       case NESTED:
17120       case NOAUDIT:
17121       case SCHEMA:
17122       case SERVERERROR:
17123       case SHUTDOWN:
17124       case STARTUP:
17125       case STATEMENT:
17126       case STATISTICS:
17127       case SUSPEND:
17128       case TRUNCATE:
17129       case WRAPPED:
17130       case LIBRARY:
17131       case NAME:
17132       case STRUCT:
17133       case CONTEXT:
17134       case PARAMETERS:
17135       case LENGTH:
17136       case TDO:
17137       case MAXLEN:
17138       case CHARSETID:
17139       case CHARSETFORM:
17140       case ACCEPT:
17141       case ACCESSIBLE:
17142       case COPY:
17143       case DEFINE:
17144       case DISCONNECT:
17145       case HOST:
17146       case PRINT:
17147       case QUIT:
17148       case REMARK:
17149       case UNDEFINE:
17150       case VARIABLE:
17151       case WHENEVER:
17152       case ATTACH:
17153       case CAST:
17154       case TREAT:
17155       case TRIM:
17156       case LEFT:
17157       case RIGHT:
17158       case BOTH:
17159       case EMPTY:
17160       case MULTISET:
17161       case SUBMULTISET:
17162       case LEADING:
17163       case TRAILING:
17164       case CHAR_CS:
17165       case NCHAR_CS:
17166       case DBTIMEZONE:
17167       case SESSIONTIMEZONE:
17168       case AUTHENTICATED:
17169       case LINK:
17170       case SHARED:
17171       case DIRECTORY:
17172       case USER:
17173       case IDENTIFIER:
17174       case UNSIGNED_NUMERIC_LITERAL:
17175       case CHARACTER_LITERAL:
17176       case STRING_LITERAL:
17177       case QUOTED_LITERAL:
17178         simpleNode = Expression();
17179                                       sb.append(" "); sb.append(simpleNode.getImage());
17180         break;
17181       default:
17182         jj_la1[216] = jj_gen;
17183         ;
17184       }
17185       label_51:
17186       while (true) {
17187         thisToken = jj_consume_token(WHEN);
17188                                  sb.append("  "); sb.append(thisToken.image);
17189         simpleNode = Expression();
17190                                             sb.append(" "); sb.append(simpleNode.getImage());
17191         thisToken = jj_consume_token(THEN);
17192                                    sb.append(" "); sb.append(thisToken.image);
17193         Expression();
17194                                  sb.append(" "); sb.append(simpleNode.getImage());
17195         switch (jj_nt.kind) {
17196         case WHEN:
17197           ;
17198           break;
17199         default:
17200           jj_la1[217] = jj_gen;
17201           break label_51;
17202         }
17203       }
17204       switch (jj_nt.kind) {
17205       case ELSE:
17206         thisToken = jj_consume_token(ELSE);
17207                                  sb.append(" "); sb.append(thisToken.image);
17208         Expression();
17209                                sb.append(" "); sb.append(simpleNode.getImage());
17210         break;
17211       default:
17212         jj_la1[218] = jj_gen;
17213         ;
17214       }
17215       thisToken = jj_consume_token(END);
17216                               sb.append(" "); sb.append(thisToken.image);
17217    jjtree.closeNodeScope(jjtn000, true);
17218    jjtc000 = false;
17219  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17220     } catch (Throwable jjte000) {
17221     if (jjtc000) {
17222       jjtree.clearNodeScope(jjtn000);
17223       jjtc000 = false;
17224     } else {
17225       jjtree.popNode();
17226     }
17227     if (jjte000 instanceof RuntimeException) {
17228       {if (true) throw (RuntimeException)jjte000;}
17229     }
17230     if (jjte000 instanceof ParseException) {
17231       {if (true) throw (ParseException)jjte000;}
17232     }
17233     {if (true) throw (Error)jjte000;}
17234     } finally {
17235     if (jjtc000) {
17236       jjtree.closeNodeScope(jjtn000, true);
17237     }
17238     }
17239     throw new Error("Missing return statement in function");
17240   }
17241 
17242 /*
17243 LIKE ( Expression ) [ <ESCAPE> <STRINGLITERAL>
17244 */
17245   final public ASTLikeExpression LikeExpression() throws ParseException {
17246  /*@bgen(jjtree) LikeExpression */
17247   ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17248   boolean jjtc000 = true;
17249   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17250     try {
17251       simpleNode = PrimaryExpression();
17252                                            sb.append(" "); sb.append(simpleNode.getImage());
17253       thisToken = jj_consume_token(LIKE);
17254                                 sb.append(thisToken.image);
17255       simpleNode = StringExpression();
17256                                             sb.append(" "); sb.append(simpleNode.getImage());
17257       switch (jj_nt.kind) {
17258       case ESCAPE:
17259         jj_consume_token(ESCAPE);
17260                    sb.append(" ESCAPE ");
17261         switch (jj_nt.kind) {
17262         case CHARACTER_LITERAL:
17263           jj_consume_token(CHARACTER_LITERAL);
17264                                 sb.append(" "); sb.append(token.toString());
17265           break;
17266         case STRING_LITERAL:
17267           simpleNode = StringLiteral();
17268                                            sb.append(" "); sb.append(simpleNode.getImage());
17269           break;
17270         default:
17271           jj_la1[219] = jj_gen;
17272           jj_consume_token(-1);
17273           throw new ParseException();
17274         }
17275         break;
17276       default:
17277         jj_la1[220] = jj_gen;
17278         ;
17279       }
17280       label_52:
17281       while (true) {
17282         switch (jj_nt.kind) {
17283         case 3:
17284           ;
17285           break;
17286         default:
17287           jj_la1[221] = jj_gen;
17288           break label_52;
17289         }
17290         jj_consume_token(3);
17291         simpleNode = Expression();
17292                                     sb.append("."); sb.append(simpleNode.getImage());
17293       }
17294    jjtree.closeNodeScope(jjtn000, true);
17295    jjtc000 = false;
17296  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17297     } catch (Throwable jjte000) {
17298     if (jjtc000) {
17299       jjtree.clearNodeScope(jjtn000);
17300       jjtc000 = false;
17301     } else {
17302       jjtree.popNode();
17303     }
17304     if (jjte000 instanceof RuntimeException) {
17305       {if (true) throw (RuntimeException)jjte000;}
17306     }
17307     if (jjte000 instanceof ParseException) {
17308       {if (true) throw (ParseException)jjte000;}
17309     }
17310     {if (true) throw (Error)jjte000;}
17311     } finally {
17312     if (jjtc000) {
17313       jjtree.closeNodeScope(jjtn000, true);
17314     }
17315     }
17316     throw new Error("Missing return statement in function");
17317   }
17318 
17319   final public ASTTrimExpression TrimExpression() throws ParseException {
17320  /*@bgen(jjtree) TrimExpression */
17321   ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17322   boolean jjtc000 = true;
17323   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17324     try {
17325       thisToken = jj_consume_token(TRIM);
17326                                 sb.append(thisToken.image);
17327       jj_consume_token(5);
17328               sb.append("(");
17329       switch (jj_nt.kind) {
17330       case BOTH:
17331       case LEADING:
17332       case TRAILING:
17333         switch (jj_nt.kind) {
17334         case LEADING:
17335           jj_consume_token(LEADING);
17336           break;
17337         case TRAILING:
17338           jj_consume_token(TRAILING);
17339           break;
17340         case BOTH:
17341           jj_consume_token(BOTH);
17342           break;
17343         default:
17344           jj_la1[222] = jj_gen;
17345           jj_consume_token(-1);
17346           throw new ParseException();
17347         }
17348                                                 sb.append(" "); sb.append(token.toString());
17349         break;
17350       default:
17351         jj_la1[223] = jj_gen;
17352         ;
17353       }
17354       switch (jj_nt.kind) {
17355       case 5:
17356       case REPLACE:
17357       case DEFINER:
17358       case CURRENT_USER:
17359       case LANGUAGE:
17360       case INLINE:
17361       case ADD:
17362       case AGGREGATE:
17363       case ARRAY:
17364       case AT:
17365       case ATTRIBUTE:
17366       case AUTHID:
17367       case BODY:
17368       case BULK:
17369       case BYTE:
17370       case CASCADE:
17371       case CASE:
17372       case CLOSE:
17373       case COALESCE:
17374       case COLLECT:
17375       case COLUMN:
17376       case COMMENT:
17377       case COMMIT:
17378       case CONSTRUCTOR:
17379       case CONTINUE:
17380       case CONVERT:
17381       case CURRENT:
17382       case CURSOR:
17383       case DATA:
17384       case DATE:
17385       case DAY:
17386       case DISABLE:
17387       case EDITIONABLE:
17388       case ELEMENT:
17389       case ENABLE:
17390       case ESCAPE:
17391       case EXCEPT:
17392       case EXCEPTIONS:
17393       case EXIT:
17394       case EXTERNAL:
17395       case EXTENDS:
17396       case EXTRACT:
17397       case FALSE:
17398       case FINAL:
17399       case FORCE:
17400       case FUNCTION:
17401       case GLOBAL:
17402       case HASH:
17403       case HEAP:
17404       case HOUR:
17405       case IMMEDIATE:
17406       case INDICES:
17407       case INDEXTYPE:
17408       case INDICATOR:
17409       case INSTANTIABLE:
17410       case INTERVAL:
17411       case INVALIDATE:
17412       case ISOLATION:
17413       case JAVA:
17414       case LEVEL:
17415       case LIMIT:
17416       case LOOP:
17417       case MAP:
17418       case MAX:
17419       case MEMBER:
17420       case MERGE:
17421       case MIN:
17422       case MINUTE:
17423       case MLSLABEL:
17424       case MODIFY:
17425       case MOD:
17426       case MONTH:
17427       case NATURAL:
17428       case NEW:
17429       case NEW_DOT:
17430       case NO:
17431       case NONEDITIONABLE:
17432       case NULL:
17433       case NULLIF:
17434       case OBJECT:
17435       case OID:
17436       case OPAQUE:
17437       case OPEN:
17438       case OPERATOR:
17439       case ORGANIZATION:
17440       case OTHERS:
17441       case OVERRIDING:
17442       case PACKAGE:
17443       case PARTITION:
17444       case PRESERVE:
17445       case PRIVATE:
17446       case PROCEDURE:
17447       case RANGE:
17448       case RAW:
17449       case REAL:
17450       case RECORD:
17451       case REF:
17452       case RELEASE:
17453       case RELIES_ON:
17454       case RENAME:
17455       case RESULT:
17456       case RETURN:
17457       case RETURNING:
17458       case REVERSE:
17459       case ROLLBACK:
17460       case ROW:
17461       case ROWS:
17462       case ROWID:
17463       case ROWNUM:
17464       case SAVE:
17465       case SAVEPOINT:
17466       case SECOND:
17467       case SELECT:
17468       case SELF:
17469       case SET:
17470       case SPACE:
17471       case SQL:
17472       case SQLCODE:
17473       case SQLERRM:
17474       case STATIC:
17475       case SUBTYPE:
17476       case SUBSTITUTABLE:
17477       case SUCCESSFUL:
17478       case SYSDATE:
17479       case SYS_REFCURSOR:
17480       case TEMPORARY:
17481       case TIME:
17482       case TIMESTAMP:
17483       case TIMEZONE_REGION:
17484       case TIMEZONE_ABBR:
17485       case TIMEZONE_MINUTE:
17486       case TIMEZONE_HOUR:
17487       case TRANSACTION:
17488       case TRUE:
17489       case TYPE:
17490       case UNDER:
17491       case USING:
17492       case YES:
17493       case SHOW:
17494       case A:
17495       case DOUBLE:
17496       case DEC:
17497       case PRECISION:
17498       case INT:
17499       case NUMERIC:
17500       case NCHAR:
17501       case NVARCHAR2:
17502       case STRING:
17503       case UROWID:
17504       case VARRAY:
17505       case VARYING:
17506       case BFILE:
17507       case BLOB:
17508       case CLOB:
17509       case NCLOB:
17510       case YEAR:
17511       case LOCAL:
17512       case WITH:
17513       case ZONE:
17514       case CHARACTER:
17515       case AFTER:
17516       case BEFORE:
17517       case OLD:
17518       case PARENT:
17519       case ANALYZE:
17520       case ASSOCIATE:
17521       case AUDIT:
17522       case COMPOUND:
17523       case DATABASE:
17524       case CALL:
17525       case DDL:
17526       case DISASSOCIATE:
17527       case EACH:
17528       case FOLLOWS:
17529       case LOGOFF:
17530       case LOGON:
17531       case NESTED:
17532       case NOAUDIT:
17533       case SCHEMA:
17534       case SERVERERROR:
17535       case SHUTDOWN:
17536       case STARTUP:
17537       case STATEMENT:
17538       case STATISTICS:
17539       case SUSPEND:
17540       case TRUNCATE:
17541       case WRAPPED:
17542       case LIBRARY:
17543       case NAME:
17544       case STRUCT:
17545       case CONTEXT:
17546       case PARAMETERS:
17547       case LENGTH:
17548       case TDO:
17549       case MAXLEN:
17550       case CHARSETID:
17551       case CHARSETFORM:
17552       case ACCEPT:
17553       case ACCESSIBLE:
17554       case COPY:
17555       case DEFINE:
17556       case DISCONNECT:
17557       case HOST:
17558       case PRINT:
17559       case QUIT:
17560       case REMARK:
17561       case UNDEFINE:
17562       case VARIABLE:
17563       case WHENEVER:
17564       case ATTACH:
17565       case CAST:
17566       case TREAT:
17567       case TRIM:
17568       case LEFT:
17569       case RIGHT:
17570       case BOTH:
17571       case EMPTY:
17572       case MULTISET:
17573       case SUBMULTISET:
17574       case LEADING:
17575       case TRAILING:
17576       case CHAR_CS:
17577       case NCHAR_CS:
17578       case DBTIMEZONE:
17579       case SESSIONTIMEZONE:
17580       case AUTHENTICATED:
17581       case LINK:
17582       case SHARED:
17583       case DIRECTORY:
17584       case USER:
17585       case IDENTIFIER:
17586       case UNSIGNED_NUMERIC_LITERAL:
17587       case CHARACTER_LITERAL:
17588       case STRING_LITERAL:
17589       case QUOTED_LITERAL:
17590         simpleNode = StringExpression();
17591                                              sb.append(" "); sb.append(simpleNode.getImage());
17592         break;
17593       default:
17594         jj_la1[224] = jj_gen;
17595         ;
17596       }
17597       jj_consume_token(FROM);
17598                         sb.append(thisToken.image);
17599       simpleNode = StringExpression();
17600                                            sb.append(" "); sb.append(simpleNode.getImage());
17601       jj_consume_token(7);
17602               sb.append(")");
17603    jjtree.closeNodeScope(jjtn000, true);
17604    jjtc000 = false;
17605  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17606     } catch (Throwable jjte000) {
17607     if (jjtc000) {
17608       jjtree.clearNodeScope(jjtn000);
17609       jjtc000 = false;
17610     } else {
17611       jjtree.popNode();
17612     }
17613     if (jjte000 instanceof RuntimeException) {
17614       {if (true) throw (RuntimeException)jjte000;}
17615     }
17616     if (jjte000 instanceof ParseException) {
17617       {if (true) throw (ParseException)jjte000;}
17618     }
17619     {if (true) throw (Error)jjte000;}
17620     } finally {
17621     if (jjtc000) {
17622       jjtree.closeNodeScope(jjtn000, true);
17623     }
17624     }
17625     throw new Error("Missing return statement in function");
17626   }
17627 
17628 /*
17629 TREAT ( Expression AS datatype)
17630 CAST ( Expression AS datatype)
17631 */
17632   final public ASTObjectExpression ObjectExpression() throws ParseException {
17633  /*@bgen(jjtree) ObjectExpression */
17634   ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17635   boolean jjtc000 = true;
17636   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17637     try {
17638       switch (jj_nt.kind) {
17639       case CAST:
17640         thisToken = jj_consume_token(CAST);
17641         break;
17642       case TREAT:
17643         thisToken = jj_consume_token(TREAT);
17644         break;
17645       default:
17646         jj_la1[225] = jj_gen;
17647         jj_consume_token(-1);
17648         throw new ParseException();
17649       }
17650                                                       sb.append(thisToken.image);
17651       jj_consume_token(5);
17652               sb.append("(");
17653       simpleNode = Expression();
17654                                       sb.append(" "); sb.append(simpleNode.getImage());
17655       switch (jj_nt.kind) {
17656       case AT:
17657         jj_consume_token(AT);
17658         jj_consume_token(TIME);
17659         jj_consume_token(ZONE);
17660         simpleNode = PrimaryExpression();
17661                                                                sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17662         break;
17663       default:
17664         jj_la1[226] = jj_gen;
17665         ;
17666       }
17667       jj_consume_token(AS);
17668                sb.append(" AS ");
17669       simpleNode = Datatype();
17670                                     sb.append(" "); sb.append(simpleNode.getImage());
17671       jj_consume_token(7);
17672               sb.append(")");
17673       label_53:
17674       while (true) {
17675         switch (jj_nt.kind) {
17676         case 3:
17677           ;
17678           break;
17679         default:
17680           jj_la1[227] = jj_gen;
17681           break label_53;
17682         }
17683         jj_consume_token(3);
17684         Expression();
17685       }
17686    jjtree.closeNodeScope(jjtn000, true);
17687    jjtc000 = false;
17688  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17689     } catch (Throwable jjte000) {
17690     if (jjtc000) {
17691       jjtree.clearNodeScope(jjtn000);
17692       jjtc000 = false;
17693     } else {
17694       jjtree.popNode();
17695     }
17696     if (jjte000 instanceof RuntimeException) {
17697       {if (true) throw (RuntimeException)jjte000;}
17698     }
17699     if (jjte000 instanceof ParseException) {
17700       {if (true) throw (ParseException)jjte000;}
17701     }
17702     {if (true) throw (Error)jjte000;}
17703     } finally {
17704     if (jjtc000) {
17705       jjtree.closeNodeScope(jjtn000, true);
17706     }
17707     }
17708     throw new Error("Missing return statement in function");
17709   }
17710 
17711   final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17712  /*@bgen(jjtree) ConditionalOrExpression */
17713   ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17714   boolean jjtc000 = true;
17715   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17716     try {
17717       simpleNode = ConditionalAndExpression();
17718                                                sb.append(simpleNode.getImage());
17719       label_54:
17720       while (true) {
17721         switch (jj_nt.kind) {
17722         case OR:
17723           ;
17724           break;
17725         default:
17726           jj_la1[228] = jj_gen;
17727           break label_54;
17728         }
17729         jj_consume_token(OR);
17730             sb.append(" OR ");
17731         simpleNode = ConditionalAndExpression();
17732                                                 sb.append(simpleNode.getImage());
17733       }
17734    jjtree.closeNodeScope(jjtn000, true);
17735    jjtc000 = false;
17736  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17737     } catch (Throwable jjte000) {
17738     if (jjtc000) {
17739       jjtree.clearNodeScope(jjtn000);
17740       jjtc000 = false;
17741     } else {
17742       jjtree.popNode();
17743     }
17744     if (jjte000 instanceof RuntimeException) {
17745       {if (true) throw (RuntimeException)jjte000;}
17746     }
17747     if (jjte000 instanceof ParseException) {
17748       {if (true) throw (ParseException)jjte000;}
17749     }
17750     {if (true) throw (Error)jjte000;}
17751     } finally {
17752     if (jjtc000) {
17753       jjtree.closeNodeScope(jjtn000, true);
17754     }
17755     }
17756     throw new Error("Missing return statement in function");
17757   }
17758 
17759   final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17760  /*@bgen(jjtree) ConditionalAndExpression */
17761   ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17762   boolean jjtc000 = true;
17763   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17764     try {
17765       simpleNode = EqualityExpression();
17766                                           sb.append(simpleNode.getImage());
17767       label_55:
17768       while (true) {
17769         switch (jj_nt.kind) {
17770         case AND:
17771           ;
17772           break;
17773         default:
17774           jj_la1[229] = jj_gen;
17775           break label_55;
17776         }
17777         jj_consume_token(AND);
17778                sb.append(" AND ");
17779         simpleNode = EqualityExpression();
17780                                             sb.append(simpleNode.getImage());
17781       }
17782    jjtree.closeNodeScope(jjtn000, true);
17783    jjtc000 = false;
17784  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17785     } catch (Throwable jjte000) {
17786     if (jjtc000) {
17787       jjtree.clearNodeScope(jjtn000);
17788       jjtc000 = false;
17789     } else {
17790       jjtree.popNode();
17791     }
17792     if (jjte000 instanceof RuntimeException) {
17793       {if (true) throw (RuntimeException)jjte000;}
17794     }
17795     if (jjte000 instanceof ParseException) {
17796       {if (true) throw (ParseException)jjte000;}
17797     }
17798     {if (true) throw (Error)jjte000;}
17799     } finally {
17800     if (jjtc000) {
17801       jjtree.closeNodeScope(jjtn000, true);
17802     }
17803     }
17804     throw new Error("Missing return statement in function");
17805   }
17806 
17807   final public ASTEqualityExpression EqualityExpression() throws ParseException {
17808  /*@bgen(jjtree) EqualityExpression */
17809   ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17810   boolean jjtc000 = true;
17811   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17812     try {
17813       simpleNode = RelationalExpression();
17814              sb.append(simpleNode.getImage());
17815       label_56:
17816       while (true) {
17817         switch (jj_nt.kind) {
17818         case 10:
17819         case 13:
17820         case IS:
17821           ;
17822           break;
17823         default:
17824           jj_la1[230] = jj_gen;
17825           break label_56;
17826         }
17827         switch (jj_nt.kind) {
17828         case 10:
17829           jj_consume_token(10);
17830                      sb.append(" = ");
17831           break;
17832         case 13:
17833           jj_consume_token(13);
17834           jj_consume_token(10);
17835                          sb.append(" != ");
17836           break;
17837         case IS:
17838           jj_consume_token(IS);
17839                      sb.append(" IS ");
17840           break;
17841         default:
17842           jj_la1[231] = jj_gen;
17843           jj_consume_token(-1);
17844           throw new ParseException();
17845         }
17846         simpleNode = RelationalExpression();
17847               sb.append(simpleNode.getImage());
17848       }
17849    jjtree.closeNodeScope(jjtn000, true);
17850    jjtc000 = false;
17851  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17852     } catch (Throwable jjte000) {
17853     if (jjtc000) {
17854       jjtree.clearNodeScope(jjtn000);
17855       jjtc000 = false;
17856     } else {
17857       jjtree.popNode();
17858     }
17859     if (jjte000 instanceof RuntimeException) {
17860       {if (true) throw (RuntimeException)jjte000;}
17861     }
17862     if (jjte000 instanceof ParseException) {
17863       {if (true) throw (ParseException)jjte000;}
17864     }
17865     {if (true) throw (Error)jjte000;}
17866     } finally {
17867     if (jjtc000) {
17868       jjtree.closeNodeScope(jjtn000, true);
17869     }
17870     }
17871     throw new Error("Missing return statement in function");
17872   }
17873 
17874 /**
17875  * 2006-05-23 - Matthias Hendler - added FROM
17876  */
17877   final public ASTRelationalExpression RelationalExpression() throws ParseException {
17878  /*@bgen(jjtree) RelationalExpression */
17879   ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17880   boolean jjtc000 = true;
17881   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17882     try {
17883       simpleNode = AdditiveExpression();
17884                                          sb.append(simpleNode.getImage());
17885       label_57:
17886       while (true) {
17887         switch (jj_nt.kind) {
17888         case 14:
17889         case 15:
17890         case BETWEEN:
17891         case FROM:
17892         case IN:
17893         case LIKE:
17894         case MEMBER:
17895         case NOT:
17896         case MULTISET:
17897         case SUBMULTISET:
17898           ;
17899           break;
17900         default:
17901           jj_la1[232] = jj_gen;
17902           break label_57;
17903         }
17904         switch (jj_nt.kind) {
17905         case 14:
17906         case 15:
17907           switch (jj_nt.kind) {
17908           case 14:
17909             jj_consume_token(14);
17910                       sb.append("<");
17911             switch (jj_nt.kind) {
17912             case 15:
17913               jj_consume_token(15);
17914                      sb.append(">");
17915               break;
17916             default:
17917               jj_la1[233] = jj_gen;
17918               ;
17919             }
17920             break;
17921           case 15:
17922             jj_consume_token(15);
17923                      sb.append(">");
17924             break;
17925           default:
17926             jj_la1[234] = jj_gen;
17927             jj_consume_token(-1);
17928             throw new ParseException();
17929           }
17930           switch (jj_nt.kind) {
17931           case 10:
17932             jj_consume_token(10);
17933                    sb.append("=");
17934             break;
17935           default:
17936             jj_la1[235] = jj_gen;
17937             ;
17938           }
17939         sb.append(" ");
17940           break;
17941         case BETWEEN:
17942         case FROM:
17943         case IN:
17944         case LIKE:
17945         case MEMBER:
17946         case NOT:
17947         case SUBMULTISET:
17948           switch (jj_nt.kind) {
17949           case NOT:
17950             jj_consume_token(NOT);
17951                 sb.append(" NOT ");
17952             break;
17953           default:
17954             jj_la1[236] = jj_gen;
17955             ;
17956           }
17957           switch (jj_nt.kind) {
17958           case IN:
17959             jj_consume_token(IN);
17960                sb.append(" IN ");
17961             break;
17962           case BETWEEN:
17963             jj_consume_token(BETWEEN);
17964                       sb.append(" BETWEEN ");
17965             break;
17966           case LIKE:
17967             jj_consume_token(LIKE);
17968                    sb.append(" LIKE ");
17969             break;
17970           case FROM:
17971             jj_consume_token(FROM);
17972                   sb.append(" FROM ");
17973             break;
17974           case MEMBER:
17975           case SUBMULTISET:
17976             switch (jj_nt.kind) {
17977             case MEMBER:
17978               jj_consume_token(MEMBER);
17979                         sb.append(" MEMBER ");
17980               break;
17981             case SUBMULTISET:
17982               jj_consume_token(SUBMULTISET);
17983                              sb.append(" SUBMULTISET ");
17984               break;
17985             default:
17986               jj_la1[237] = jj_gen;
17987               jj_consume_token(-1);
17988               throw new ParseException();
17989             }
17990             switch (jj_nt.kind) {
17991             case OF:
17992               jj_consume_token(OF);
17993                   sb.append(" OF ");
17994               break;
17995             default:
17996               jj_la1[238] = jj_gen;
17997               ;
17998             }
17999             break;
18000           default:
18001             jj_la1[239] = jj_gen;
18002             jj_consume_token(-1);
18003             throw new ParseException();
18004           }
18005           break;
18006         case MULTISET:
18007           jj_consume_token(MULTISET);
18008                     sb.append (" MULTISET " );
18009           switch (jj_nt.kind) {
18010           case EXCEPT:
18011             jj_consume_token(EXCEPT);
18012                        sb.append (" EXCEPT " );
18013             break;
18014           case INTERSECT:
18015             jj_consume_token(INTERSECT);
18016                           sb.append (" INTERSECT " );
18017             break;
18018           case UNION:
18019             jj_consume_token(UNION);
18020                       sb.append (" UNION " );
18021             break;
18022           default:
18023             jj_la1[240] = jj_gen;
18024             jj_consume_token(-1);
18025             throw new ParseException();
18026           }
18027           switch (jj_nt.kind) {
18028           case ALL:
18029           case DISTINCT:
18030             switch (jj_nt.kind) {
18031             case DISTINCT:
18032               jj_consume_token(DISTINCT);
18033                          sb.append (" DISTINCT " );
18034               break;
18035             case ALL:
18036               jj_consume_token(ALL);
18037                     sb.append (" ALL " );
18038               break;
18039             default:
18040               jj_la1[241] = jj_gen;
18041               jj_consume_token(-1);
18042               throw new ParseException();
18043             }
18044             break;
18045           default:
18046             jj_la1[242] = jj_gen;
18047             ;
18048           }
18049           break;
18050         default:
18051           jj_la1[243] = jj_gen;
18052           jj_consume_token(-1);
18053           throw new ParseException();
18054         }
18055         AdditiveExpression();
18056                              sb.append(simpleNode.getImage());
18057         switch (jj_nt.kind) {
18058         case ESCAPE:
18059           jj_consume_token(ESCAPE);
18060                    sb.append(" ESCAPE ");
18061           switch (jj_nt.kind) {
18062           case CHARACTER_LITERAL:
18063             jj_consume_token(CHARACTER_LITERAL);
18064                                 sb.append(" "); sb.append(token.toString());
18065             break;
18066           case STRING_LITERAL:
18067             simpleNode = StringLiteral();
18068                                            sb.append(" "); sb.append(simpleNode.getImage());
18069             break;
18070           default:
18071             jj_la1[244] = jj_gen;
18072             jj_consume_token(-1);
18073             throw new ParseException();
18074           }
18075           break;
18076         default:
18077           jj_la1[245] = jj_gen;
18078           ;
18079         }
18080       }
18081    jjtree.closeNodeScope(jjtn000, true);
18082    jjtc000 = false;
18083  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18084     } catch (Throwable jjte000) {
18085    if (jjtc000) {
18086      jjtree.clearNodeScope(jjtn000);
18087      jjtc000 = false;
18088    } else {
18089      jjtree.popNode();
18090    }
18091    if (jjte000 instanceof RuntimeException) {
18092      {if (true) throw (RuntimeException)jjte000;}
18093    }
18094    if (jjte000 instanceof ParseException) {
18095      {if (true) throw (ParseException)jjte000;}
18096    }
18097    {if (true) throw (Error)jjte000;}
18098     } finally {
18099    if (jjtc000) {
18100      jjtree.closeNodeScope(jjtn000, true);
18101    }
18102     }
18103     throw new Error("Missing return statement in function");
18104   }
18105 
18106   final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
18107  /*@bgen(jjtree) AdditiveExpression */
18108   ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
18109   boolean jjtc000 = true;
18110   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18111     try {
18112       simpleNode = MultiplicativeExpression();
18113                                                sb.append(simpleNode.getImage());
18114       label_58:
18115       while (true) {
18116         switch (jj_nt.kind) {
18117         case 16:
18118         case 17:
18119         case 18:
18120           ;
18121           break;
18122         default:
18123           jj_la1[246] = jj_gen;
18124           break label_58;
18125         }
18126         switch (jj_nt.kind) {
18127         case 16:
18128           jj_consume_token(16);
18129                sb.append(" + ");
18130           break;
18131         case 17:
18132           jj_consume_token(17);
18133                sb.append(" - ");
18134           break;
18135         case 18:
18136           jj_consume_token(18);
18137                 sb.append(" || ");
18138           break;
18139         default:
18140           jj_la1[247] = jj_gen;
18141           jj_consume_token(-1);
18142           throw new ParseException();
18143         }
18144         simpleNode = MultiplicativeExpression();
18145                                                  sb.append(simpleNode.getImage());
18146       }
18147    jjtree.closeNodeScope(jjtn000, true);
18148    jjtc000 = false;
18149  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18150     } catch (Throwable jjte000) {
18151    if (jjtc000) {
18152      jjtree.clearNodeScope(jjtn000);
18153      jjtc000 = false;
18154    } else {
18155      jjtree.popNode();
18156    }
18157    if (jjte000 instanceof RuntimeException) {
18158      {if (true) throw (RuntimeException)jjte000;}
18159    }
18160    if (jjte000 instanceof ParseException) {
18161      {if (true) throw (ParseException)jjte000;}
18162    }
18163    {if (true) throw (Error)jjte000;}
18164     } finally {
18165    if (jjtc000) {
18166      jjtree.closeNodeScope(jjtn000, true);
18167    }
18168     }
18169     throw new Error("Missing return statement in function");
18170   }
18171 
18172   final public ASTStringExpression StringExpression() throws ParseException {
18173  /*@bgen(jjtree) StringExpression */
18174   ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18175   boolean jjtc000 = true;
18176   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18177     try {
18178       simpleNode = PrimaryExpression();
18179                                         sb.append(simpleNode.getImage());
18180       label_59:
18181       while (true) {
18182         switch (jj_nt.kind) {
18183         case 18:
18184           ;
18185           break;
18186         default:
18187           jj_la1[248] = jj_gen;
18188           break label_59;
18189         }
18190         jj_consume_token(18);
18191                sb.append(" || ");
18192         simpleNode = PrimaryExpression();
18193                                           sb.append(simpleNode.getImage());
18194       }
18195    jjtree.closeNodeScope(jjtn000, true);
18196    jjtc000 = false;
18197  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18198     } catch (Throwable jjte000) {
18199    if (jjtc000) {
18200      jjtree.clearNodeScope(jjtn000);
18201      jjtc000 = false;
18202    } else {
18203      jjtree.popNode();
18204    }
18205    if (jjte000 instanceof RuntimeException) {
18206      {if (true) throw (RuntimeException)jjte000;}
18207    }
18208    if (jjte000 instanceof ParseException) {
18209      {if (true) throw (ParseException)jjte000;}
18210    }
18211    {if (true) throw (Error)jjte000;}
18212     } finally {
18213    if (jjtc000) {
18214      jjtree.closeNodeScope(jjtn000, true);
18215    }
18216     }
18217     throw new Error("Missing return statement in function");
18218   }
18219 
18220   final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18221  /*@bgen(jjtree) MultiplicativeExpression */
18222   ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18223   boolean jjtc000 = true;
18224   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18225     try {
18226       simpleNode = UnaryExpression(true);
18227                                           sb.append(simpleNode.getImage());
18228       label_60:
18229       while (true) {
18230         switch (jj_nt.kind) {
18231         case 1:
18232         case 19:
18233         case 20:
18234         case MOD:
18235           ;
18236           break;
18237         default:
18238           jj_la1[249] = jj_gen;
18239           break label_60;
18240         }
18241         switch (jj_nt.kind) {
18242         case 19:
18243           jj_consume_token(19);
18244                  sb.append(" ** ");
18245           break;
18246         case 20:
18247           jj_consume_token(20);
18248                 sb.append(" * ");
18249           break;
18250         case 1:
18251           jj_consume_token(1);
18252                 sb.append(" / ");
18253           break;
18254         case MOD:
18255           jj_consume_token(MOD);
18256                   sb.append(" MOD ");
18257           break;
18258         default:
18259           jj_la1[250] = jj_gen;
18260           jj_consume_token(-1);
18261           throw new ParseException();
18262         }
18263         simpleNode = UnaryExpression(true);
18264                                             sb.append(simpleNode.getImage());
18265       }
18266    jjtree.closeNodeScope(jjtn000, true);
18267    jjtc000 = false;
18268  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18269     } catch (Throwable jjte000) {
18270    if (jjtc000) {
18271      jjtree.clearNodeScope(jjtn000);
18272      jjtc000 = false;
18273    } else {
18274      jjtree.popNode();
18275    }
18276    if (jjte000 instanceof RuntimeException) {
18277      {if (true) throw (RuntimeException)jjte000;}
18278    }
18279    if (jjte000 instanceof ParseException) {
18280      {if (true) throw (ParseException)jjte000;}
18281    }
18282    {if (true) throw (Error)jjte000;}
18283     } finally {
18284    if (jjtc000) {
18285      jjtree.closeNodeScope(jjtn000, true);
18286    }
18287     }
18288     throw new Error("Missing return statement in function");
18289   }
18290 
18291   final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18292  /*@bgen(jjtree) UnaryExpression */
18293   ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18294   boolean jjtc000 = true;
18295   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18296     try {
18297       switch (jj_nt.kind) {
18298       case 16:
18299       case 17:
18300         switch (jj_nt.kind) {
18301         case 16:
18302           jj_consume_token(16);
18303               sb.append(isUnarySign ? " +" : " + ");
18304           break;
18305         case 17:
18306           jj_consume_token(17);
18307               sb.append(isUnarySign ? " -" : " - ");
18308           break;
18309         default:
18310           jj_la1[251] = jj_gen;
18311           jj_consume_token(-1);
18312           throw new ParseException();
18313         }
18314         simpleNode = UnaryExpression(false);
18315                                             sb.append(simpleNode.getImage());
18316         break;
18317       case 5:
18318       case REPLACE:
18319       case DEFINER:
18320       case CURRENT_USER:
18321       case LANGUAGE:
18322       case INLINE:
18323       case ADD:
18324       case AGGREGATE:
18325       case ARRAY:
18326       case AT:
18327       case ATTRIBUTE:
18328       case AUTHID:
18329       case BODY:
18330       case BULK:
18331       case BYTE:
18332       case CASCADE:
18333       case CASE:
18334       case CLOSE:
18335       case COALESCE:
18336       case COLLECT:
18337       case COLUMN:
18338       case COMMENT:
18339       case COMMIT:
18340       case CONSTRUCTOR:
18341       case CONTINUE:
18342       case CONVERT:
18343       case CURRENT:
18344       case CURSOR:
18345       case DATA:
18346       case DATE:
18347       case DAY:
18348       case DISABLE:
18349       case EDITIONABLE:
18350       case ELEMENT:
18351       case ENABLE:
18352       case ESCAPE:
18353       case EXCEPT:
18354       case EXCEPTIONS:
18355       case EXIT:
18356       case EXTERNAL:
18357       case EXTENDS:
18358       case EXTRACT:
18359       case FALSE:
18360       case FINAL:
18361       case FORCE:
18362       case FUNCTION:
18363       case GLOBAL:
18364       case HASH:
18365       case HEAP:
18366       case HOUR:
18367       case IMMEDIATE:
18368       case INDICES:
18369       case INDEXTYPE:
18370       case INDICATOR:
18371       case INSTANTIABLE:
18372       case INTERVAL:
18373       case INVALIDATE:
18374       case ISOLATION:
18375       case JAVA:
18376       case LEVEL:
18377       case LIMIT:
18378       case LOOP:
18379       case MAP:
18380       case MAX:
18381       case MEMBER:
18382       case MERGE:
18383       case MIN:
18384       case MINUTE:
18385       case MLSLABEL:
18386       case MODIFY:
18387       case MOD:
18388       case MONTH:
18389       case NATURAL:
18390       case NEW:
18391       case NEW_DOT:
18392       case NO:
18393       case NONEDITIONABLE:
18394       case NOT:
18395       case NULL:
18396       case NULLIF:
18397       case OBJECT:
18398       case OID:
18399       case OPAQUE:
18400       case OPEN:
18401       case OPERATOR:
18402       case ORGANIZATION:
18403       case OTHERS:
18404       case OVERRIDING:
18405       case PACKAGE:
18406       case PARTITION:
18407       case PRESERVE:
18408       case PRIVATE:
18409       case PROCEDURE:
18410       case RANGE:
18411       case RAW:
18412       case REAL:
18413       case RECORD:
18414       case REF:
18415       case RELEASE:
18416       case RELIES_ON:
18417       case RENAME:
18418       case RESULT:
18419       case RETURN:
18420       case RETURNING:
18421       case REVERSE:
18422       case ROLLBACK:
18423       case ROW:
18424       case ROWS:
18425       case ROWID:
18426       case ROWNUM:
18427       case SAVE:
18428       case SAVEPOINT:
18429       case SECOND:
18430       case SELECT:
18431       case SELF:
18432       case SET:
18433       case SPACE:
18434       case SQL:
18435       case SQLCODE:
18436       case SQLERRM:
18437       case STATIC:
18438       case SUBTYPE:
18439       case SUBSTITUTABLE:
18440       case SUCCESSFUL:
18441       case SYSDATE:
18442       case SYS_REFCURSOR:
18443       case TEMPORARY:
18444       case TIME:
18445       case TIMESTAMP:
18446       case TIMEZONE_REGION:
18447       case TIMEZONE_ABBR:
18448       case TIMEZONE_MINUTE:
18449       case TIMEZONE_HOUR:
18450       case TRANSACTION:
18451       case TRUE:
18452       case TYPE:
18453       case UNDER:
18454       case USING:
18455       case YES:
18456       case SHOW:
18457       case A:
18458       case DOUBLE:
18459       case DEC:
18460       case PRECISION:
18461       case INT:
18462       case NUMERIC:
18463       case NCHAR:
18464       case NVARCHAR2:
18465       case STRING:
18466       case UROWID:
18467       case VARRAY:
18468       case VARYING:
18469       case BFILE:
18470       case BLOB:
18471       case CLOB:
18472       case NCLOB:
18473       case YEAR:
18474       case LOCAL:
18475       case WITH:
18476       case ZONE:
18477       case CHARACTER:
18478       case AFTER:
18479       case BEFORE:
18480       case OLD:
18481       case PARENT:
18482       case ANALYZE:
18483       case ASSOCIATE:
18484       case AUDIT:
18485       case COMPOUND:
18486       case DATABASE:
18487       case CALL:
18488       case DDL:
18489       case DISASSOCIATE:
18490       case EACH:
18491       case FOLLOWS:
18492       case LOGOFF:
18493       case LOGON:
18494       case NESTED:
18495       case NOAUDIT:
18496       case SCHEMA:
18497       case SERVERERROR:
18498       case SHUTDOWN:
18499       case STARTUP:
18500       case STATEMENT:
18501       case STATISTICS:
18502       case SUSPEND:
18503       case TRUNCATE:
18504       case WRAPPED:
18505       case LIBRARY:
18506       case NAME:
18507       case STRUCT:
18508       case CONTEXT:
18509       case PARAMETERS:
18510       case LENGTH:
18511       case TDO:
18512       case MAXLEN:
18513       case CHARSETID:
18514       case CHARSETFORM:
18515       case ACCEPT:
18516       case ACCESSIBLE:
18517       case COPY:
18518       case DEFINE:
18519       case DISCONNECT:
18520       case HOST:
18521       case PRINT:
18522       case QUIT:
18523       case REMARK:
18524       case UNDEFINE:
18525       case VARIABLE:
18526       case WHENEVER:
18527       case ATTACH:
18528       case CAST:
18529       case TREAT:
18530       case TRIM:
18531       case LEFT:
18532       case RIGHT:
18533       case BOTH:
18534       case EMPTY:
18535       case MULTISET:
18536       case SUBMULTISET:
18537       case LEADING:
18538       case TRAILING:
18539       case CHAR_CS:
18540       case NCHAR_CS:
18541       case DBTIMEZONE:
18542       case SESSIONTIMEZONE:
18543       case AUTHENTICATED:
18544       case LINK:
18545       case SHARED:
18546       case DIRECTORY:
18547       case USER:
18548       case IDENTIFIER:
18549       case UNSIGNED_NUMERIC_LITERAL:
18550       case CHARACTER_LITERAL:
18551       case STRING_LITERAL:
18552       case QUOTED_LITERAL:
18553         simpleNode = UnaryExpressionNotPlusMinus();
18554                                                    sb.append(simpleNode.getImage());
18555         break;
18556       default:
18557         jj_la1[252] = jj_gen;
18558         jj_consume_token(-1);
18559         throw new ParseException();
18560       }
18561    jjtree.closeNodeScope(jjtn000, true);
18562    jjtc000 = false;
18563  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18564     } catch (Throwable jjte000) {
18565    if (jjtc000) {
18566      jjtree.clearNodeScope(jjtn000);
18567      jjtc000 = false;
18568    } else {
18569      jjtree.popNode();
18570    }
18571    if (jjte000 instanceof RuntimeException) {
18572      {if (true) throw (RuntimeException)jjte000;}
18573    }
18574    if (jjte000 instanceof ParseException) {
18575      {if (true) throw (ParseException)jjte000;}
18576    }
18577    {if (true) throw (Error)jjte000;}
18578     } finally {
18579    if (jjtc000) {
18580      jjtree.closeNodeScope(jjtn000, true);
18581    }
18582     }
18583     throw new Error("Missing return statement in function");
18584   }
18585 
18586   final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18587  /*@bgen(jjtree) UnaryExpressionNotPlusMinus */
18588   ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18589   boolean jjtc000 = true;
18590   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18591     try {
18592       switch (jj_nt.kind) {
18593       case NOT:
18594         jj_consume_token(NOT);
18595            sb.append(" NOT ");
18596         simpleNode = UnaryExpression(false);
18597                                            sb.append(simpleNode.getImage());
18598         break;
18599       case 5:
18600       case REPLACE:
18601       case DEFINER:
18602       case CURRENT_USER:
18603       case LANGUAGE:
18604       case INLINE:
18605       case ADD:
18606       case AGGREGATE:
18607       case ARRAY:
18608       case AT:
18609       case ATTRIBUTE:
18610       case AUTHID:
18611       case BODY:
18612       case BULK:
18613       case BYTE:
18614       case CASCADE:
18615       case CASE:
18616       case CLOSE:
18617       case COALESCE:
18618       case COLLECT:
18619       case COLUMN:
18620       case COMMENT:
18621       case COMMIT:
18622       case CONSTRUCTOR:
18623       case CONTINUE:
18624       case CONVERT:
18625       case CURRENT:
18626       case CURSOR:
18627       case DATA:
18628       case DATE:
18629       case DAY:
18630       case DISABLE:
18631       case EDITIONABLE:
18632       case ELEMENT:
18633       case ENABLE:
18634       case ESCAPE:
18635       case EXCEPT:
18636       case EXCEPTIONS:
18637       case EXIT:
18638       case EXTERNAL:
18639       case EXTENDS:
18640       case EXTRACT:
18641       case FALSE:
18642       case FINAL:
18643       case FORCE:
18644       case FUNCTION:
18645       case GLOBAL:
18646       case HASH:
18647       case HEAP:
18648       case HOUR:
18649       case IMMEDIATE:
18650       case INDICES:
18651       case INDEXTYPE:
18652       case INDICATOR:
18653       case INSTANTIABLE:
18654       case INTERVAL:
18655       case INVALIDATE:
18656       case ISOLATION:
18657       case JAVA:
18658       case LEVEL:
18659       case LIMIT:
18660       case LOOP:
18661       case MAP:
18662       case MAX:
18663       case MEMBER:
18664       case MERGE:
18665       case MIN:
18666       case MINUTE:
18667       case MLSLABEL:
18668       case MODIFY:
18669       case MOD:
18670       case MONTH:
18671       case NATURAL:
18672       case NEW:
18673       case NEW_DOT:
18674       case NO:
18675       case NONEDITIONABLE:
18676       case NULL:
18677       case NULLIF:
18678       case OBJECT:
18679       case OID:
18680       case OPAQUE:
18681       case OPEN:
18682       case OPERATOR:
18683       case ORGANIZATION:
18684       case OTHERS:
18685       case OVERRIDING:
18686       case PACKAGE:
18687       case PARTITION:
18688       case PRESERVE:
18689       case PRIVATE:
18690       case PROCEDURE:
18691       case RANGE:
18692       case RAW:
18693       case REAL:
18694       case RECORD:
18695       case REF:
18696       case RELEASE:
18697       case RELIES_ON:
18698       case RENAME:
18699       case RESULT:
18700       case RETURN:
18701       case RETURNING:
18702       case REVERSE:
18703       case ROLLBACK:
18704       case ROW:
18705       case ROWS:
18706       case ROWID:
18707       case ROWNUM:
18708       case SAVE:
18709       case SAVEPOINT:
18710       case SECOND:
18711       case SELECT:
18712       case SELF:
18713       case SET:
18714       case SPACE:
18715       case SQL:
18716       case SQLCODE:
18717       case SQLERRM:
18718       case STATIC:
18719       case SUBTYPE:
18720       case SUBSTITUTABLE:
18721       case SUCCESSFUL:
18722       case SYSDATE:
18723       case SYS_REFCURSOR:
18724       case TEMPORARY:
18725       case TIME:
18726       case TIMESTAMP:
18727       case TIMEZONE_REGION:
18728       case TIMEZONE_ABBR:
18729       case TIMEZONE_MINUTE:
18730       case TIMEZONE_HOUR:
18731       case TRANSACTION:
18732       case TRUE:
18733       case TYPE:
18734       case UNDER:
18735       case USING:
18736       case YES:
18737       case SHOW:
18738       case A:
18739       case DOUBLE:
18740       case DEC:
18741       case PRECISION:
18742       case INT:
18743       case NUMERIC:
18744       case NCHAR:
18745       case NVARCHAR2:
18746       case STRING:
18747       case UROWID:
18748       case VARRAY:
18749       case VARYING:
18750       case BFILE:
18751       case BLOB:
18752       case CLOB:
18753       case NCLOB:
18754       case YEAR:
18755       case LOCAL:
18756       case WITH:
18757       case ZONE:
18758       case CHARACTER:
18759       case AFTER:
18760       case BEFORE:
18761       case OLD:
18762       case PARENT:
18763       case ANALYZE:
18764       case ASSOCIATE:
18765       case AUDIT:
18766       case COMPOUND:
18767       case DATABASE:
18768       case CALL:
18769       case DDL:
18770       case DISASSOCIATE:
18771       case EACH:
18772       case FOLLOWS:
18773       case LOGOFF:
18774       case LOGON:
18775       case NESTED:
18776       case NOAUDIT:
18777       case SCHEMA:
18778       case SERVERERROR:
18779       case SHUTDOWN:
18780       case STARTUP:
18781       case STATEMENT:
18782       case STATISTICS:
18783       case SUSPEND:
18784       case TRUNCATE:
18785       case WRAPPED:
18786       case LIBRARY:
18787       case NAME:
18788       case STRUCT:
18789       case CONTEXT:
18790       case PARAMETERS:
18791       case LENGTH:
18792       case TDO:
18793       case MAXLEN:
18794       case CHARSETID:
18795       case CHARSETFORM:
18796       case ACCEPT:
18797       case ACCESSIBLE:
18798       case COPY:
18799       case DEFINE:
18800       case DISCONNECT:
18801       case HOST:
18802       case PRINT:
18803       case QUIT:
18804       case REMARK:
18805       case UNDEFINE:
18806       case VARIABLE:
18807       case WHENEVER:
18808       case ATTACH:
18809       case CAST:
18810       case TREAT:
18811       case TRIM:
18812       case LEFT:
18813       case RIGHT:
18814       case BOTH:
18815       case EMPTY:
18816       case MULTISET:
18817       case SUBMULTISET:
18818       case LEADING:
18819       case TRAILING:
18820       case CHAR_CS:
18821       case NCHAR_CS:
18822       case DBTIMEZONE:
18823       case SESSIONTIMEZONE:
18824       case AUTHENTICATED:
18825       case LINK:
18826       case SHARED:
18827       case DIRECTORY:
18828       case USER:
18829       case IDENTIFIER:
18830       case UNSIGNED_NUMERIC_LITERAL:
18831       case CHARACTER_LITERAL:
18832       case STRING_LITERAL:
18833       case QUOTED_LITERAL:
18834         simpleNode = IsNullCondition();
18835                                       sb.append(simpleNode.getImage());
18836         break;
18837       default:
18838         jj_la1[253] = jj_gen;
18839         jj_consume_token(-1);
18840         throw new ParseException();
18841       }
18842    jjtree.closeNodeScope(jjtn000, true);
18843    jjtc000 = false;
18844  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18845     } catch (Throwable jjte000) {
18846     if (jjtc000) {
18847       jjtree.clearNodeScope(jjtn000);
18848       jjtc000 = false;
18849     } else {
18850       jjtree.popNode();
18851     }
18852     if (jjte000 instanceof RuntimeException) {
18853       {if (true) throw (RuntimeException)jjte000;}
18854     }
18855     if (jjte000 instanceof ParseException) {
18856       {if (true) throw (ParseException)jjte000;}
18857     }
18858     {if (true) throw (Error)jjte000;}
18859     } finally {
18860     if (jjtc000) {
18861       jjtree.closeNodeScope(jjtn000, true);
18862     }
18863     }
18864     throw new Error("Missing return statement in function");
18865   }
18866 
18867   final public ASTIsNullCondition IsNullCondition() throws ParseException {
18868  /*@bgen(jjtree) IsNullCondition */
18869   ASTIsNullCondition jjtn000 = new ASTIsNullCondition(this, JJTISNULLCONDITION);
18870   boolean jjtc000 = true;
18871   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
18872     try {
18873       if (jj_2_46(2147483647)) {
18874         name = Name();
18875                                  sb.append(name.getImage());
18876         jj_consume_token(IS);
18877                                                                     sb.append(" IS");
18878         switch (jj_nt.kind) {
18879         case NOT:
18880           jj_consume_token(NOT);
18881                                                                                                sb.append(" NOT");
18882           break;
18883         default:
18884           jj_la1[254] = jj_gen;
18885           ;
18886         }
18887         jj_consume_token(NULL);
18888                                                                                                                             sb.append(" NULL");
18889       } else {
18890         switch (jj_nt.kind) {
18891         case 5:
18892         case REPLACE:
18893         case DEFINER:
18894         case CURRENT_USER:
18895         case LANGUAGE:
18896         case INLINE:
18897         case ADD:
18898         case AGGREGATE:
18899         case ARRAY:
18900         case AT:
18901         case ATTRIBUTE:
18902         case AUTHID:
18903         case BODY:
18904         case BULK:
18905         case BYTE:
18906         case CASCADE:
18907         case CASE:
18908         case CLOSE:
18909         case COALESCE:
18910         case COLLECT:
18911         case COLUMN:
18912         case COMMENT:
18913         case COMMIT:
18914         case CONSTRUCTOR:
18915         case CONTINUE:
18916         case CONVERT:
18917         case CURRENT:
18918         case CURSOR:
18919         case DATA:
18920         case DATE:
18921         case DAY:
18922         case DISABLE:
18923         case EDITIONABLE:
18924         case ELEMENT:
18925         case ENABLE:
18926         case ESCAPE:
18927         case EXCEPT:
18928         case EXCEPTIONS:
18929         case EXIT:
18930         case EXTERNAL:
18931         case EXTENDS:
18932         case EXTRACT:
18933         case FALSE:
18934         case FINAL:
18935         case FORCE:
18936         case FUNCTION:
18937         case GLOBAL:
18938         case HASH:
18939         case HEAP:
18940         case HOUR:
18941         case IMMEDIATE:
18942         case INDICES:
18943         case INDEXTYPE:
18944         case INDICATOR:
18945         case INSTANTIABLE:
18946         case INTERVAL:
18947         case INVALIDATE:
18948         case ISOLATION:
18949         case JAVA:
18950         case LEVEL:
18951         case LIMIT:
18952         case LOOP:
18953         case MAP:
18954         case MAX:
18955         case MEMBER:
18956         case MERGE:
18957         case MIN:
18958         case MINUTE:
18959         case MLSLABEL:
18960         case MODIFY:
18961         case MOD:
18962         case MONTH:
18963         case NATURAL:
18964         case NEW:
18965         case NEW_DOT:
18966         case NO:
18967         case NONEDITIONABLE:
18968         case NULL:
18969         case NULLIF:
18970         case OBJECT:
18971         case OID:
18972         case OPAQUE:
18973         case OPEN:
18974         case OPERATOR:
18975         case ORGANIZATION:
18976         case OTHERS:
18977         case OVERRIDING:
18978         case PACKAGE:
18979         case PARTITION:
18980         case PRESERVE:
18981         case PRIVATE:
18982         case PROCEDURE:
18983         case RANGE:
18984         case RAW:
18985         case REAL:
18986         case RECORD:
18987         case REF:
18988         case RELEASE:
18989         case RELIES_ON:
18990         case RENAME:
18991         case RESULT:
18992         case RETURN:
18993         case RETURNING:
18994         case REVERSE:
18995         case ROLLBACK:
18996         case ROW:
18997         case ROWS:
18998         case ROWID:
18999         case ROWNUM:
19000         case SAVE:
19001         case SAVEPOINT:
19002         case SECOND:
19003         case SELECT:
19004         case SELF:
19005         case SET:
19006         case SPACE:
19007         case SQL:
19008         case SQLCODE:
19009         case SQLERRM:
19010         case STATIC:
19011         case SUBTYPE:
19012         case SUBSTITUTABLE:
19013         case SUCCESSFUL:
19014         case SYSDATE:
19015         case SYS_REFCURSOR:
19016         case TEMPORARY:
19017         case TIME:
19018         case TIMESTAMP:
19019         case TIMEZONE_REGION:
19020         case TIMEZONE_ABBR:
19021         case TIMEZONE_MINUTE:
19022         case TIMEZONE_HOUR:
19023         case TRANSACTION:
19024         case TRUE:
19025         case TYPE:
19026         case UNDER:
19027         case USING:
19028         case YES:
19029         case SHOW:
19030         case A:
19031         case DOUBLE:
19032         case DEC:
19033         case PRECISION:
19034         case INT:
19035         case NUMERIC:
19036         case NCHAR:
19037         case NVARCHAR2:
19038         case STRING:
19039         case UROWID:
19040         case VARRAY:
19041         case VARYING:
19042         case BFILE:
19043         case BLOB:
19044         case CLOB:
19045         case NCLOB:
19046         case YEAR:
19047         case LOCAL:
19048         case WITH:
19049         case ZONE:
19050         case CHARACTER:
19051         case AFTER:
19052         case BEFORE:
19053         case OLD:
19054         case PARENT:
19055         case ANALYZE:
19056         case ASSOCIATE:
19057         case AUDIT:
19058         case COMPOUND:
19059         case DATABASE:
19060         case CALL:
19061         case DDL:
19062         case DISASSOCIATE:
19063         case EACH:
19064         case FOLLOWS:
19065         case LOGOFF:
19066         case LOGON:
19067         case NESTED:
19068         case NOAUDIT:
19069         case SCHEMA:
19070         case SERVERERROR:
19071         case SHUTDOWN:
19072         case STARTUP:
19073         case STATEMENT:
19074         case STATISTICS:
19075         case SUSPEND:
19076         case TRUNCATE:
19077         case WRAPPED:
19078         case LIBRARY:
19079         case NAME:
19080         case STRUCT:
19081         case CONTEXT:
19082         case PARAMETERS:
19083         case LENGTH:
19084         case TDO:
19085         case MAXLEN:
19086         case CHARSETID:
19087         case CHARSETFORM:
19088         case ACCEPT:
19089         case ACCESSIBLE:
19090         case COPY:
19091         case DEFINE:
19092         case DISCONNECT:
19093         case HOST:
19094         case PRINT:
19095         case QUIT:
19096         case REMARK:
19097         case UNDEFINE:
19098         case VARIABLE:
19099         case WHENEVER:
19100         case ATTACH:
19101         case CAST:
19102         case TREAT:
19103         case TRIM:
19104         case LEFT:
19105         case RIGHT:
19106         case BOTH:
19107         case EMPTY:
19108         case MULTISET:
19109         case SUBMULTISET:
19110         case LEADING:
19111         case TRAILING:
19112         case CHAR_CS:
19113         case NCHAR_CS:
19114         case DBTIMEZONE:
19115         case SESSIONTIMEZONE:
19116         case AUTHENTICATED:
19117         case LINK:
19118         case SHARED:
19119         case DIRECTORY:
19120         case USER:
19121         case IDENTIFIER:
19122         case UNSIGNED_NUMERIC_LITERAL:
19123         case CHARACTER_LITERAL:
19124         case STRING_LITERAL:
19125         case QUOTED_LITERAL:
19126           simpleNode = IsOfTypeCondition();
19127                 sb.append(simpleNode.getImage());
19128           break;
19129         default:
19130           jj_la1[255] = jj_gen;
19131           jj_consume_token(-1);
19132           throw new ParseException();
19133         }
19134       }
19135     jjtree.closeNodeScope(jjtn000, true);
19136     jjtc000 = false;
19137     jjtn000.setImage(sb.toString());
19138         {if (true) return jjtn000;}
19139     } catch (Throwable jjte000) {
19140     if (jjtc000) {
19141       jjtree.clearNodeScope(jjtn000);
19142       jjtc000 = false;
19143     } else {
19144       jjtree.popNode();
19145     }
19146     if (jjte000 instanceof RuntimeException) {
19147       {if (true) throw (RuntimeException)jjte000;}
19148     }
19149     if (jjte000 instanceof ParseException) {
19150       {if (true) throw (ParseException)jjte000;}
19151     }
19152     {if (true) throw (Error)jjte000;}
19153     } finally {
19154     if (jjtc000) {
19155       jjtree.closeNodeScope(jjtn000, true);
19156     }
19157     }
19158     throw new Error("Missing return statement in function");
19159   }
19160 
19161   final public ASTIsOfTypeCondition IsOfTypeCondition() throws ParseException {
19162  /*@bgen(jjtree) IsOfTypeCondition */
19163   ASTIsOfTypeCondition jjtn000 = new ASTIsOfTypeCondition(this, JJTISOFTYPECONDITION);
19164   boolean jjtc000 = true;
19165   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
19166     try {
19167       if (jj_2_47(2147483647)) {
19168         name = Name();
19169                       sb.append(name.getImage());
19170         jj_consume_token(IS);
19171                                                          sb.append(" IS");
19172         switch (jj_nt.kind) {
19173         case NOT:
19174           jj_consume_token(NOT);
19175                                                                                     sb.append(" NOT");
19176           break;
19177         default:
19178           jj_la1[256] = jj_gen;
19179           ;
19180         }
19181         jj_consume_token(OF);
19182                                                                                                                sb.append(" OF");
19183         switch (jj_nt.kind) {
19184         case TYPE:
19185           jj_consume_token(TYPE);
19186           break;
19187         default:
19188           jj_la1[257] = jj_gen;
19189           ;
19190         }
19191         jj_consume_token(5);
19192         switch (jj_nt.kind) {
19193         case ONLY:
19194           jj_consume_token(ONLY);
19195           break;
19196         default:
19197           jj_la1[258] = jj_gen;
19198           ;
19199         }
19200         Name();
19201         label_61:
19202         while (true) {
19203           switch (jj_nt.kind) {
19204           case 6:
19205             ;
19206             break;
19207           default:
19208             jj_la1[259] = jj_gen;
19209             break label_61;
19210           }
19211           jj_consume_token(6);
19212           switch (jj_nt.kind) {
19213           case ONLY:
19214             jj_consume_token(ONLY);
19215             break;
19216           default:
19217             jj_la1[260] = jj_gen;
19218             ;
19219           }
19220           Name();
19221         }
19222         jj_consume_token(7);
19223       } else {
19224         switch (jj_nt.kind) {
19225         case 5:
19226         case REPLACE:
19227         case DEFINER:
19228         case CURRENT_USER:
19229         case LANGUAGE:
19230         case INLINE:
19231         case ADD:
19232         case AGGREGATE:
19233         case ARRAY:
19234         case AT:
19235         case ATTRIBUTE:
19236         case AUTHID:
19237         case BODY:
19238         case BULK:
19239         case BYTE:
19240         case CASCADE:
19241         case CASE:
19242         case CLOSE:
19243         case COALESCE:
19244         case COLLECT:
19245         case COLUMN:
19246         case COMMENT:
19247         case COMMIT:
19248         case CONSTRUCTOR:
19249         case CONTINUE:
19250         case CONVERT:
19251         case CURRENT:
19252         case CURSOR:
19253         case DATA:
19254         case DATE:
19255         case DAY:
19256         case DISABLE:
19257         case EDITIONABLE:
19258         case ELEMENT:
19259         case ENABLE:
19260         case ESCAPE:
19261         case EXCEPT:
19262         case EXCEPTIONS:
19263         case EXIT:
19264         case EXTERNAL:
19265         case EXTENDS:
19266         case EXTRACT:
19267         case FALSE:
19268         case FINAL:
19269         case FORCE:
19270         case FUNCTION:
19271         case GLOBAL:
19272         case HASH:
19273         case HEAP:
19274         case HOUR:
19275         case IMMEDIATE:
19276         case INDICES:
19277         case INDEXTYPE:
19278         case INDICATOR:
19279         case INSTANTIABLE:
19280         case INTERVAL:
19281         case INVALIDATE:
19282         case ISOLATION:
19283         case JAVA:
19284         case LEVEL:
19285         case LIMIT:
19286         case LOOP:
19287         case MAP:
19288         case MAX:
19289         case MEMBER:
19290         case MERGE:
19291         case MIN:
19292         case MINUTE:
19293         case MLSLABEL:
19294         case MODIFY:
19295         case MOD:
19296         case MONTH:
19297         case NATURAL:
19298         case NEW:
19299         case NEW_DOT:
19300         case NO:
19301         case NONEDITIONABLE:
19302         case NULL:
19303         case NULLIF:
19304         case OBJECT:
19305         case OID:
19306         case OPAQUE:
19307         case OPEN:
19308         case OPERATOR:
19309         case ORGANIZATION:
19310         case OTHERS:
19311         case OVERRIDING:
19312         case PACKAGE:
19313         case PARTITION:
19314         case PRESERVE:
19315         case PRIVATE:
19316         case PROCEDURE:
19317         case RANGE:
19318         case RAW:
19319         case REAL:
19320         case RECORD:
19321         case REF:
19322         case RELEASE:
19323         case RELIES_ON:
19324         case RENAME:
19325         case RESULT:
19326         case RETURN:
19327         case RETURNING:
19328         case REVERSE:
19329         case ROLLBACK:
19330         case ROW:
19331         case ROWS:
19332         case ROWID:
19333         case ROWNUM:
19334         case SAVE:
19335         case SAVEPOINT:
19336         case SECOND:
19337         case SELECT:
19338         case SELF:
19339         case SET:
19340         case SPACE:
19341         case SQL:
19342         case SQLCODE:
19343         case SQLERRM:
19344         case STATIC:
19345         case SUBTYPE:
19346         case SUBSTITUTABLE:
19347         case SUCCESSFUL:
19348         case SYSDATE:
19349         case SYS_REFCURSOR:
19350         case TEMPORARY:
19351         case TIME:
19352         case TIMESTAMP:
19353         case TIMEZONE_REGION:
19354         case TIMEZONE_ABBR:
19355         case TIMEZONE_MINUTE:
19356         case TIMEZONE_HOUR:
19357         case TRANSACTION:
19358         case TRUE:
19359         case TYPE:
19360         case UNDER:
19361         case USING:
19362         case YES:
19363         case SHOW:
19364         case A:
19365         case DOUBLE:
19366         case DEC:
19367         case PRECISION:
19368         case INT:
19369         case NUMERIC:
19370         case NCHAR:
19371         case NVARCHAR2:
19372         case STRING:
19373         case UROWID:
19374         case VARRAY:
19375         case VARYING:
19376         case BFILE:
19377         case BLOB:
19378         case CLOB:
19379         case NCLOB:
19380         case YEAR:
19381         case LOCAL:
19382         case WITH:
19383         case ZONE:
19384         case CHARACTER:
19385         case AFTER:
19386         case BEFORE:
19387         case OLD:
19388         case PARENT:
19389         case ANALYZE:
19390         case ASSOCIATE:
19391         case AUDIT:
19392         case COMPOUND:
19393         case DATABASE:
19394         case CALL:
19395         case DDL:
19396         case DISASSOCIATE:
19397         case EACH:
19398         case FOLLOWS:
19399         case LOGOFF:
19400         case LOGON:
19401         case NESTED:
19402         case NOAUDIT:
19403         case SCHEMA:
19404         case SERVERERROR:
19405         case SHUTDOWN:
19406         case STARTUP:
19407         case STATEMENT:
19408         case STATISTICS:
19409         case SUSPEND:
19410         case TRUNCATE:
19411         case WRAPPED:
19412         case LIBRARY:
19413         case NAME:
19414         case STRUCT:
19415         case CONTEXT:
19416         case PARAMETERS:
19417         case LENGTH:
19418         case TDO:
19419         case MAXLEN:
19420         case CHARSETID:
19421         case CHARSETFORM:
19422         case ACCEPT:
19423         case ACCESSIBLE:
19424         case COPY:
19425         case DEFINE:
19426         case DISCONNECT:
19427         case HOST:
19428         case PRINT:
19429         case QUIT:
19430         case REMARK:
19431         case UNDEFINE:
19432         case VARIABLE:
19433         case WHENEVER:
19434         case ATTACH:
19435         case CAST:
19436         case TREAT:
19437         case TRIM:
19438         case LEFT:
19439         case RIGHT:
19440         case BOTH:
19441         case EMPTY:
19442         case MULTISET:
19443         case SUBMULTISET:
19444         case LEADING:
19445         case TRAILING:
19446         case CHAR_CS:
19447         case NCHAR_CS:
19448         case DBTIMEZONE:
19449         case SESSIONTIMEZONE:
19450         case AUTHENTICATED:
19451         case LINK:
19452         case SHARED:
19453         case DIRECTORY:
19454         case USER:
19455         case IDENTIFIER:
19456         case UNSIGNED_NUMERIC_LITERAL:
19457         case CHARACTER_LITERAL:
19458         case STRING_LITERAL:
19459         case QUOTED_LITERAL:
19460           simpleNode = PrimaryExpression();
19461                                           sb.append(simpleNode.getImage());
19462           break;
19463         default:
19464           jj_la1[261] = jj_gen;
19465           jj_consume_token(-1);
19466           throw new ParseException();
19467         }
19468       }
19469     jjtree.closeNodeScope(jjtn000, true);
19470     jjtc000 = false;
19471     jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19472     } catch (Throwable jjte000) {
19473     if (jjtc000) {
19474       jjtree.clearNodeScope(jjtn000);
19475       jjtc000 = false;
19476     } else {
19477       jjtree.popNode();
19478     }
19479     if (jjte000 instanceof RuntimeException) {
19480       {if (true) throw (RuntimeException)jjte000;}
19481     }
19482     if (jjte000 instanceof ParseException) {
19483       {if (true) throw (ParseException)jjte000;}
19484     }
19485     {if (true) throw (Error)jjte000;}
19486     } finally {
19487     if (jjtc000) {
19488       jjtree.closeNodeScope(jjtn000, true);
19489     }
19490     }
19491     throw new Error("Missing return statement in function");
19492   }
19493 
19494 /**
19495  * 2006-05-23 - Matthias Hendler - Added lookahead otherwise warning encountered.
19496  *                                 Warning arised while adding methode triggerUnit(). 
19497  * 2011-04-27 - SRT - Add optional NEW Keyword to cope with Object Type constructors
19498  */
19499   final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
19500  /*@bgen(jjtree) PrimaryExpression */
19501   ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
19502   boolean jjtc000 = true;
19503   jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19504     try {
19505       switch (jj_nt.kind) {
19506       case NEW_DOT:
19507         jj_consume_token(NEW_DOT);
19508         simpleNode = QualifiedID();
19509                                                        sb.append(" NEW."); sb.append(simpleNode.getImage());
19510         break;
19511       case 5:
19512       case REPLACE:
19513       case DEFINER:
19514       case CURRENT_USER:
19515       case LANGUAGE:
19516       case INLINE:
19517       case ADD:
19518       case AGGREGATE:
19519       case ARRAY:
19520       case AT:
19521       case ATTRIBUTE:
19522       case AUTHID:
19523       case BODY:
19524       case BULK:
19525       case BYTE:
19526       case CASCADE:
19527       case CASE:
19528       case CLOSE:
19529       case COALESCE:
19530       case COLLECT:
19531       case COLUMN:
19532       case COMMENT:
19533       case COMMIT:
19534       case CONSTRUCTOR:
19535       case CONTINUE:
19536       case CONVERT:
19537       case CURRENT:
19538       case CURSOR:
19539       case DATA:
19540       case DATE:
19541       case DAY:
19542       case DISABLE:
19543       case EDITIONABLE:
19544       case ELEMENT:
19545       case ENABLE:
19546       case ESCAPE:
19547       case EXCEPT:
19548       case EXCEPTIONS:
19549       case EXIT:
19550       case EXTERNAL:
19551       case EXTENDS:
19552       case EXTRACT:
19553       case FALSE:
19554       case FINAL:
19555       case FORCE:
19556       case FUNCTION:
19557       case GLOBAL:
19558       case HASH:
19559       case HEAP:
19560       case HOUR:
19561       case IMMEDIATE:
19562       case INDICES:
19563       case INDEXTYPE:
19564       case INDICATOR:
19565       case INSTANTIABLE:
19566       case INTERVAL:
19567       case INVALIDATE:
19568       case ISOLATION:
19569       case JAVA:
19570       case LEVEL:
19571       case LIMIT:
19572       case LOOP:
19573       case MAP:
19574       case MAX:
19575       case MEMBER:
19576       case MERGE:
19577       case MIN:
19578       case MINUTE:
19579       case MLSLABEL:
19580       case MODIFY:
19581       case MOD:
19582       case MONTH:
19583       case NATURAL:
19584       case NEW:
19585       case NO:
19586       case NONEDITIONABLE:
19587       case NULL:
19588       case NULLIF:
19589       case OBJECT:
19590       case OID:
19591       case OPAQUE:
19592       case OPEN:
19593       case OPERATOR:
19594       case ORGANIZATION:
19595       case OTHERS:
19596       case OVERRIDING:
19597       case PACKAGE:
19598       case PARTITION:
19599       case PRESERVE:
19600       case PRIVATE:
19601       case PROCEDURE:
19602       case RANGE:
19603       case RAW:
19604       case REAL:
19605       case RECORD:
19606       case REF:
19607       case RELEASE:
19608       case RELIES_ON:
19609       case RENAME:
19610       case RESULT:
19611       case RETURN:
19612       case RETURNING:
19613       case REVERSE:
19614       case ROLLBACK:
19615       case ROW:
19616       case ROWS:
19617       case ROWID:
19618       case ROWNUM:
19619       case SAVE:
19620       case SAVEPOINT:
19621       case SECOND:
19622       case SELECT:
19623       case SELF:
19624       case SET:
19625       case SPACE:
19626       case SQL:
19627       case SQLCODE:
19628       case SQLERRM:
19629       case STATIC:
19630       case SUBTYPE:
19631       case SUBSTITUTABLE:
19632       case SUCCESSFUL:
19633       case SYSDATE:
19634       case SYS_REFCURSOR:
19635       case TEMPORARY:
19636       case TIME:
19637       case TIMESTAMP:
19638       case TIMEZONE_REGION:
19639       case TIMEZONE_ABBR:
19640       case TIMEZONE_MINUTE:
19641       case TIMEZONE_HOUR:
19642       case TRANSACTION:
19643       case TRUE:
19644       case TYPE:
19645       case UNDER:
19646       case USING:
19647       case YES:
19648       case SHOW:
19649       case A:
19650       case DOUBLE:
19651       case DEC:
19652       case PRECISION:
19653       case INT:
19654       case NUMERIC:
19655       case NCHAR:
19656       case NVARCHAR2:
19657       case STRING:
19658       case UROWID:
19659       case VARRAY:
19660       case VARYING:
19661       case BFILE:
19662       case BLOB:
19663       case CLOB:
19664       case NCLOB:
19665       case YEAR:
19666       case LOCAL:
19667       case WITH:
19668       case ZONE:
19669       case CHARACTER:
19670       case AFTER:
19671       case BEFORE:
19672       case OLD:
19673       case PARENT:
19674       case ANALYZE:
19675       case ASSOCIATE:
19676       case AUDIT:
19677       case COMPOUND:
19678       case DATABASE:
19679       case CALL:
19680       case DDL:
19681       case DISASSOCIATE:
19682       case EACH:
19683       case FOLLOWS:
19684       case LOGOFF:
19685       case LOGON:
19686       case NESTED:
19687       case NOAUDIT:
19688       case SCHEMA:
19689       case SERVERERROR:
19690       case SHUTDOWN:
19691       case STARTUP:
19692       case STATEMENT:
19693       case STATISTICS:
19694       case SUSPEND:
19695       case TRUNCATE:
19696       case WRAPPED:
19697       case LIBRARY:
19698       case NAME:
19699       case STRUCT:
19700       case CONTEXT:
19701       case PARAMETERS:
19702       case LENGTH:
19703       case TDO:
19704       case MAXLEN:
19705       case CHARSETID:
19706       case CHARSETFORM:
19707       case ACCEPT:
19708       case ACCESSIBLE:
19709       case COPY:
19710       case DEFINE:
19711       case DISCONNECT:
19712       case HOST:
19713       case PRINT:
19714       case QUIT:
19715       case REMARK:
19716       case UNDEFINE:
19717       case VARIABLE:
19718       case WHENEVER:
19719       case ATTACH:
19720       case CAST:
19721       case TREAT:
19722       case TRIM:
19723       case LEFT:
19724       case RIGHT:
19725       case BOTH:
19726       case EMPTY:
19727       case MULTISET:
19728       case SUBMULTISET:
19729       case LEADING:
19730       case TRAILING:
19731       case CHAR_CS:
19732       case NCHAR_CS:
19733       case DBTIMEZONE:
19734       case SESSIONTIMEZONE:
19735       case AUTHENTICATED:
19736       case LINK:
19737       case SHARED:
19738       case DIRECTORY:
19739       case USER:
19740       case IDENTIFIER:
19741       case UNSIGNED_NUMERIC_LITERAL:
19742       case CHARACTER_LITERAL:
19743       case STRING_LITERAL:
19744       case QUOTED_LITERAL:
19745         if (jj_2_48(2147483647)) {
19746           jj_consume_token(NEW);
19747                 sb.append(" NEW ");
19748           simpleNode = PrimaryPrefix();
19749                                                                        sb.append(simpleNode.getImage());
19750         } else {
19751           switch (jj_nt.kind) {
19752           case 5:
19753           case REPLACE:
19754           case DEFINER:
19755           case CURRENT_USER:
19756           case LANGUAGE:
19757           case INLINE:
19758           case ADD:
19759           case AGGREGATE:
19760           case ARRAY:
19761           case AT:
19762           case ATTRIBUTE:
19763           case AUTHID:
19764           case BODY:
19765           case BULK:
19766           case BYTE:
19767           case CASCADE:
19768           case CASE:
19769           case CLOSE:
19770           case COALESCE:
19771           case COLLECT:
19772           case COLUMN:
19773           case COMMENT:
19774           case COMMIT:
19775           case CONSTRUCTOR:
19776           case CONTINUE:
19777           case CONVERT:
19778           case CURRENT:
19779           case CURSOR:
19780           case DATA:
19781           case DATE:
19782           case DAY:
19783           case DISABLE:
19784           case EDITIONABLE:
19785           case ELEMENT:
19786           case ENABLE:
19787           case ESCAPE:
19788           case EXCEPT:
19789           case EXCEPTIONS:
19790           case EXIT:
19791           case EXTERNAL:
19792           case EXTENDS:
19793           case EXTRACT:
19794           case FALSE:
19795           case FINAL:
19796           case FORCE:
19797           case FUNCTION:
19798           case GLOBAL:
19799           case HASH:
19800           case HEAP:
19801           case HOUR:
19802           case IMMEDIATE:
19803           case INDICES:
19804           case INDEXTYPE:
19805           case INDICATOR:
19806           case INSTANTIABLE:
19807           case INTERVAL:
19808           case INVALIDATE:
19809           case ISOLATION:
19810           case JAVA:
19811           case LEVEL:
19812           case LIMIT:
19813           case LOOP:
19814           case MAP:
19815           case MAX:
19816           case MEMBER:
19817           case MERGE:
19818           case MIN:
19819           case MINUTE:
19820           case MLSLABEL:
19821           case MODIFY:
19822           case MOD:
19823           case MONTH:
19824           case NATURAL:
19825           case NEW:
19826           case NO:
19827           case NONEDITIONABLE:
19828           case NULL:
19829           case NULLIF:
19830           case OBJECT:
19831           case OID:
19832           case OPAQUE:
19833           case OPEN:
19834           case OPERATOR:
19835           case ORGANIZATION:
19836           case OTHERS:
19837           case OVERRIDING:
19838           case PACKAGE:
19839           case PARTITION:
19840           case PRESERVE:
19841           case PRIVATE:
19842           case PROCEDURE:
19843           case RANGE:
19844           case RAW:
19845           case REAL:
19846           case RECORD:
19847           case REF:
19848           case RELEASE:
19849           case RELIES_ON:
19850           case RENAME:
19851           case RESULT:
19852           case RETURN:
19853           case RETURNING:
19854           case REVERSE:
19855           case ROLLBACK:
19856           case ROW:
19857           case ROWS:
19858           case ROWID:
19859           case ROWNUM:
19860           case SAVE:
19861           case SAVEPOINT:
19862           case SECOND:
19863           case SELECT:
19864           case SELF:
19865           case SET:
19866           case SPACE:
19867           case SQL:
19868           case SQLCODE:
19869           case SQLERRM:
19870           case STATIC:
19871           case SUBTYPE:
19872           case SUBSTITUTABLE:
19873           case SUCCESSFUL:
19874           case SYSDATE:
19875           case SYS_REFCURSOR:
19876           case TEMPORARY:
19877           case TIME:
19878           case TIMESTAMP:
19879           case TIMEZONE_REGION:
19880           case TIMEZONE_ABBR:
19881           case TIMEZONE_MINUTE:
19882           case TIMEZONE_HOUR:
19883           case TRANSACTION:
19884           case TRUE:
19885           case TYPE:
19886           case UNDER:
19887           case USING:
19888           case YES:
19889           case SHOW:
19890           case A:
19891           case DOUBLE:
19892           case DEC:
19893           case PRECISION:
19894           case INT:
19895           case NUMERIC:
19896           case NCHAR:
19897           case NVARCHAR2:
19898           case STRING:
19899           case UROWID:
19900           case VARRAY:
19901           case VARYING:
19902           case BFILE:
19903           case BLOB:
19904           case CLOB:
19905           case NCLOB:
19906           case YEAR:
19907           case LOCAL:
19908           case WITH:
19909           case ZONE:
19910           case CHARACTER:
19911           case AFTER:
19912           case BEFORE:
19913           case OLD:
19914           case PARENT:
19915           case ANALYZE:
19916           case ASSOCIATE:
19917           case AUDIT:
19918           case COMPOUND:
19919           case DATABASE:
19920           case CALL:
19921           case DDL:
19922           case DISASSOCIATE:
19923           case EACH:
19924           case FOLLOWS:
19925           case LOGOFF:
19926           case LOGON:
19927           case NESTED:
19928           case NOAUDIT:
19929           case SCHEMA:
19930           case SERVERERROR:
19931           case SHUTDOWN:
19932           case STARTUP:
19933           case STATEMENT:
19934           case STATISTICS:
19935           case SUSPEND:
19936           case TRUNCATE:
19937           case WRAPPED:
19938           case LIBRARY:
19939           case NAME:
19940           case STRUCT:
19941           case CONTEXT:
19942           case PARAMETERS:
19943           case LENGTH:
19944           case TDO:
19945           case MAXLEN:
19946           case CHARSETID:
19947           case CHARSETFORM:
19948           case ACCEPT:
19949           case ACCESSIBLE:
19950           case COPY:
19951           case DEFINE:
19952           case DISCONNECT:
19953           case HOST:
19954           case PRINT:
19955           case QUIT:
19956           case REMARK:
19957           case UNDEFINE:
19958           case VARIABLE:
19959           case WHENEVER:
19960           case ATTACH:
19961           case CAST:
19962           case TREAT:
19963           case TRIM:
19964           case LEFT:
19965           case RIGHT:
19966           case BOTH:
19967           case EMPTY:
19968           case MULTISET:
19969           case SUBMULTISET:
19970           case LEADING:
19971           case TRAILING:
19972           case CHAR_CS:
19973           case NCHAR_CS:
19974           case DBTIMEZONE:
19975           case SESSIONTIMEZONE:
19976           case AUTHENTICATED:
19977           case LINK:
19978           case SHARED:
19979           case DIRECTORY:
19980           case USER:
19981           case IDENTIFIER:
19982           case UNSIGNED_NUMERIC_LITERAL:
19983           case CHARACTER_LITERAL:
19984           case STRING_LITERAL:
19985           case QUOTED_LITERAL:
19986             simpleNode = PrimaryPrefix();
19987                                                sb.append(simpleNode.getImage());
19988             break;
19989           default:
19990             jj_la1[262] = jj_gen;
19991             jj_consume_token(-1);
19992             throw new ParseException();
19993           }
19994         }
19995         label_62:
19996         while (true) {
19997           if (jj_2_49(2)) {
19998             ;
19999           } else {
20000             break label_62;
20001           }
20002           simpleNode = PrimarySuffix();
20003                                                            sb.append(simpleNode.getImage());
20004         }
20005         break;
20006       default:
20007         jj_la1[263] = jj_gen;
20008         jj_consume_token(-1);
20009         throw new ParseException();
20010       }
20011    jjtree.closeNodeScope(jjtn000, true);
20012    jjtc000 = false;
20013  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20014     } catch (Throwable jjte000) {
20015     if (jjtc000) {
20016       jjtree.clearNodeScope(jjtn000);
20017       jjtc000 = false;
20018     } else {
20019       jjtree.popNode();
20020     }
20021     if (jjte000 instanceof RuntimeException) {
20022       {if (true) throw (RuntimeException)jjte000;}
20023     }
20024     if (jjte000 instanceof ParseException) {
20025       {if (true) throw (ParseException)jjte000;}
20026     }
20027     {if (true) throw (Error)jjte000;}
20028     } finally {
20029     if (jjtc000) {
20030       jjtree.closeNodeScope(jjtn000, true);
20031     }
20032     }
20033     throw new Error("Missing return statement in function");
20034   }
20035 
20036   final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
20037  /*@bgen(jjtree) PrimaryPrefix */
20038   ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
20039   boolean jjtc000 = true;
20040   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
20041     try {
20042       switch (jj_nt.kind) {
20043       case DATE:
20044       case FALSE:
20045       case INTERVAL:
20046       case NULL:
20047       case TIMESTAMP:
20048       case TRUE:
20049       case UNSIGNED_NUMERIC_LITERAL:
20050       case CHARACTER_LITERAL:
20051       case STRING_LITERAL:
20052         simpleNode = Literal();
20053                                sb.append(simpleNode.getImage()) ;
20054         break;
20055       default:
20056         jj_la1[265] = jj_gen;
20057         if (jj_2_50(2147483647)) {
20058           simpleNode = MultiSetCondition();
20059         } else if (jj_2_51(2147483647)) {
20060           simpleNode = TrimExpression();
20061         } else if (jj_2_52(2147483647)) {
20062           simpleNode = CaseExpression();
20063                                                                  sb.append(simpleNode.getImage()) ;
20064         } else if (jj_2_53(2147483647)) {
20065           simpleNode = ObjectExpression();
20066                                                                        sb.append(simpleNode.getImage()) ;
20067         } else {
20068           switch (jj_nt.kind) {
20069           case REPLACE:
20070           case DEFINER:
20071           case CURRENT_USER:
20072           case LANGUAGE:
20073           case INLINE:
20074           case ADD:
20075           case AGGREGATE:
20076           case ARRAY:
20077           case AT:
20078           case ATTRIBUTE:
20079           case AUTHID:
20080           case BODY:
20081           case BULK:
20082           case BYTE:
20083           case CASCADE:
20084           case CLOSE:
20085           case COALESCE:
20086           case COLLECT:
20087           case COLUMN:
20088           case COMMENT:
20089           case COMMIT:
20090           case CONSTRUCTOR:
20091           case CONTINUE:
20092           case CONVERT:
20093           case CURRENT:
20094           case CURSOR:
20095           case DATA:
20096           case DAY:
20097           case DISABLE:
20098           case EDITIONABLE:
20099           case ELEMENT:
20100           case ENABLE:
20101           case ESCAPE:
20102           case EXCEPT:
20103           case EXCEPTIONS:
20104           case EXIT:
20105           case EXTERNAL:
20106           case EXTENDS:
20107           case EXTRACT:
20108           case FALSE:
20109           case FINAL:
20110           case FORCE:
20111           case FUNCTION:
20112           case GLOBAL:
20113           case HASH:
20114           case HEAP:
20115           case HOUR:
20116           case IMMEDIATE:
20117           case INDICES:
20118           case INDEXTYPE:
20119           case INDICATOR:
20120           case INSTANTIABLE:
20121           case INTERVAL:
20122           case INVALIDATE:
20123           case ISOLATION:
20124           case JAVA:
20125           case LEVEL:
20126           case LIMIT:
20127           case LOOP:
20128           case MAP:
20129           case MAX:
20130           case MEMBER:
20131           case MERGE:
20132           case MIN:
20133           case MINUTE:
20134           case MLSLABEL:
20135           case MODIFY:
20136           case MOD:
20137           case MONTH:
20138           case NATURAL:
20139           case NEW:
20140           case NO:
20141           case NONEDITIONABLE:
20142           case NULLIF:
20143           case OBJECT:
20144           case OID:
20145           case OPAQUE:
20146           case OPEN:
20147           case OPERATOR:
20148           case ORGANIZATION:
20149           case OTHERS:
20150           case OVERRIDING:
20151           case PACKAGE:
20152           case PARTITION:
20153           case PRESERVE:
20154           case PRIVATE:
20155           case PROCEDURE:
20156           case RANGE:
20157           case RAW:
20158           case REAL:
20159           case RECORD:
20160           case REF:
20161           case RELEASE:
20162           case RELIES_ON:
20163           case RENAME:
20164           case RESULT:
20165           case RETURN:
20166           case RETURNING:
20167           case REVERSE:
20168           case ROLLBACK:
20169           case ROW:
20170           case ROWS:
20171           case ROWID:
20172           case ROWNUM:
20173           case SAVE:
20174           case SAVEPOINT:
20175           case SECOND:
20176           case SELF:
20177           case SET:
20178           case SPACE:
20179           case SQL:
20180           case SQLCODE:
20181           case SQLERRM:
20182           case STATIC:
20183           case SUBTYPE:
20184           case SUBSTITUTABLE:
20185           case SUCCESSFUL:
20186           case SYSDATE:
20187           case SYS_REFCURSOR:
20188           case TEMPORARY:
20189           case TIME:
20190           case TIMESTAMP:
20191           case TIMEZONE_REGION:
20192           case TIMEZONE_ABBR:
20193           case TIMEZONE_MINUTE:
20194           case TIMEZONE_HOUR:
20195           case TRANSACTION:
20196           case TRUE:
20197           case TYPE:
20198           case UNDER:
20199           case USING:
20200           case YES:
20201           case SHOW:
20202           case A:
20203           case DOUBLE:
20204           case DEC:
20205           case PRECISION:
20206           case INT:
20207           case NUMERIC:
20208           case NCHAR:
20209           case NVARCHAR2:
20210           case STRING:
20211           case UROWID:
20212           case VARRAY:
20213           case VARYING:
20214           case BFILE:
20215           case BLOB:
20216           case CLOB:
20217           case NCLOB:
20218           case YEAR:
20219           case LOCAL:
20220           case ZONE:
20221           case CHARACTER:
20222           case AFTER:
20223           case BEFORE:
20224           case OLD:
20225           case PARENT:
20226           case ANALYZE:
20227           case ASSOCIATE:
20228           case AUDIT:
20229           case COMPOUND:
20230           case DATABASE:
20231           case CALL:
20232           case DDL:
20233           case DISASSOCIATE:
20234           case EACH:
20235           case FOLLOWS:
20236           case LOGOFF:
20237           case LOGON:
20238           case NESTED:
20239           case NOAUDIT:
20240           case SCHEMA:
20241           case SERVERERROR:
20242           case SHUTDOWN:
20243           case STARTUP:
20244           case STATEMENT:
20245           case STATISTICS:
20246           case SUSPEND:
20247           case TRUNCATE:
20248           case WRAPPED:
20249           case LIBRARY:
20250           case NAME:
20251           case STRUCT:
20252           case CONTEXT:
20253           case PARAMETERS:
20254           case LENGTH:
20255           case TDO:
20256           case MAXLEN:
20257           case CHARSETID:
20258           case CHARSETFORM:
20259           case ACCEPT:
20260           case ACCESSIBLE:
20261           case COPY:
20262           case DEFINE:
20263           case DISCONNECT:
20264           case HOST:
20265           case PRINT:
20266           case QUIT:
20267           case REMARK:
20268           case UNDEFINE:
20269           case VARIABLE:
20270           case WHENEVER:
20271           case ATTACH:
20272           case CAST:
20273           case TREAT:
20274           case TRIM:
20275           case LEFT:
20276           case RIGHT:
20277           case BOTH:
20278           case EMPTY:
20279           case MULTISET:
20280           case SUBMULTISET:
20281           case LEADING:
20282           case TRAILING:
20283           case CHAR_CS:
20284           case NCHAR_CS:
20285           case DBTIMEZONE:
20286           case SESSIONTIMEZONE:
20287           case AUTHENTICATED:
20288           case LINK:
20289           case SHARED:
20290           case DIRECTORY:
20291           case USER:
20292           case IDENTIFIER:
20293           case QUOTED_LITERAL:
20294             simpleNode = Name();
20295                            sb.append(simpleNode.getImage()) ;
20296             break;
20297           default:
20298             jj_la1[266] = jj_gen;
20299             if (jj_2_54(2147483647)) {
20300               jj_consume_token(SELECT);
20301                                   sb.append("SELECT ...");
20302               Skip2NextTerminator(null,";");
20303             } else if (jj_2_55(2147483647)) {
20304               jj_consume_token(5);
20305                                     sb.append("(SELECT ...");
20306               Skip2NextTerminator("(",")");
20307               jj_consume_token(7);
20308             } else if (jj_2_56(2147483647)) {
20309               jj_consume_token(WITH);
20310                               sb.append("WITH ...");
20311               Skip2NextTerminator(null,";");
20312             } else if (jj_2_57(2147483647)) {
20313               jj_consume_token(5);
20314                                   sb.append("(WITH ...");
20315               Skip2NextTerminator("(",")");
20316               jj_consume_token(7);
20317             } else {
20318               switch (jj_nt.kind) {
20319               case 5:
20320                 jj_consume_token(5);
20321           sb.append("(");
20322                 simpleNode = Expression();
20323                                 sb.append(simpleNode.getImage());
20324                 label_63:
20325                 while (true) {
20326                   switch (jj_nt.kind) {
20327                   case 6:
20328                     ;
20329                     break;
20330                   default:
20331                     jj_la1[264] = jj_gen;
20332                     break label_63;
20333                   }
20334                   jj_consume_token(6);
20335            sb.append(", ");
20336                   simpleNode = Expression();
20337                                   sb.append(simpleNode.getImage());
20338                 }
20339                 jj_consume_token(7);
20340          sb.append(")");
20341                 break;
20342               default:
20343                 jj_la1[267] = jj_gen;
20344                 jj_consume_token(-1);
20345                 throw new ParseException();
20346               }
20347             }
20348           }
20349         }
20350       }
20351    jjtree.closeNodeScope(jjtn000, true);
20352    jjtc000 = false;
20353  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20354     } catch (Throwable jjte000) {
20355   if (jjtc000) {
20356     jjtree.clearNodeScope(jjtn000);
20357     jjtc000 = false;
20358   } else {
20359     jjtree.popNode();
20360   }
20361   if (jjte000 instanceof RuntimeException) {
20362     {if (true) throw (RuntimeException)jjte000;}
20363   }
20364   if (jjte000 instanceof ParseException) {
20365     {if (true) throw (ParseException)jjte000;}
20366   }
20367   {if (true) throw (Error)jjte000;}
20368     } finally {
20369   if (jjtc000) {
20370     jjtree.closeNodeScope(jjtn000, true);
20371   }
20372     }
20373     throw new Error("Missing return statement in function");
20374   }
20375 
20376   final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
20377  /*@bgen(jjtree) PrimarySuffix */
20378   ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
20379   boolean jjtc000 = true;
20380   jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
20381     try {
20382       switch (jj_nt.kind) {
20383       case 3:
20384         jj_consume_token(3);
20385          sb.append(".");
20386         suffixNode = QualifiedID();
20387                                                            sb.append(suffixNode.toString()) ;
20388         break;
20389       case 2:
20390         jj_consume_token(2);
20391          sb.append("@");
20392         suffixNode = QualifiedID();
20393                                                            sb.append(suffixNode.toString()) ;
20394         break;
20395       case AT:
20396         jj_consume_token(AT);
20397           sb.append(" "); sb.append(token.image.toUpperCase());
20398         switch (jj_nt.kind) {
20399         case LOCAL:
20400           jj_consume_token(LOCAL);
20401                       sb.append(" "); sb.append(token.image.toUpperCase());
20402           break;
20403         case TIME:
20404           jj_consume_token(TIME);
20405           jj_consume_token(ZONE);
20406                                sb.append(" TIME ZONE");
20407           switch (jj_nt.kind) {
20408           case DBTIMEZONE:
20409             jj_consume_token(DBTIMEZONE);
20410                                   sb.append(" "); sb.append(token.image.toUpperCase());
20411             break;
20412           case SESSIONTIMEZONE:
20413             jj_consume_token(SESSIONTIMEZONE);
20414                                        sb.append(" "); sb.append(token.image.toUpperCase());
20415             break;
20416           case STRING_LITERAL:
20417             suffixNode = StringLiteral();
20418                                                   sb.append(" "); sb.append(suffixNode.toString());
20419             break;
20420           case 5:
20421           case 16:
20422           case 17:
20423           case REPLACE:
20424           case DEFINER:
20425           case CURRENT_USER:
20426           case LANGUAGE:
20427           case INLINE:
20428           case ADD:
20429           case AGGREGATE:
20430           case ARRAY:
20431           case AT:
20432           case ATTRIBUTE:
20433           case AUTHID:
20434           case BODY:
20435           case BULK:
20436           case BYTE:
20437           case CASCADE:
20438           case CASE:
20439           case CLOSE:
20440           case COALESCE:
20441           case COLLECT:
20442           case COLUMN:
20443           case COMMENT:
20444           case COMMIT:
20445           case CONSTRUCTOR:
20446           case CONTINUE:
20447           case CONVERT:
20448           case CURRENT:
20449           case CURSOR:
20450           case DATA:
20451           case DATE:
20452           case DAY:
20453           case DISABLE:
20454           case EDITIONABLE:
20455           case ELEMENT:
20456           case ENABLE:
20457           case ESCAPE:
20458           case EXCEPT:
20459           case EXCEPTIONS:
20460           case EXIT:
20461           case EXTERNAL:
20462           case EXTENDS:
20463           case EXTRACT:
20464           case FALSE:
20465           case FINAL:
20466           case FORCE:
20467           case FUNCTION:
20468           case GLOBAL:
20469           case HASH:
20470           case HEAP:
20471           case HOUR:
20472           case IMMEDIATE:
20473           case INDICES:
20474           case INDEXTYPE:
20475           case INDICATOR:
20476           case INSTANTIABLE:
20477           case INTERVAL:
20478           case INVALIDATE:
20479           case ISOLATION:
20480           case JAVA:
20481           case LEVEL:
20482           case LIMIT:
20483           case LOOP:
20484           case MAP:
20485           case MAX:
20486           case MEMBER:
20487           case MERGE:
20488           case MIN:
20489           case MINUTE:
20490           case MLSLABEL:
20491           case MODIFY:
20492           case MOD:
20493           case MONTH:
20494           case NATURAL:
20495           case NEW:
20496           case NEW_DOT:
20497           case NO:
20498           case NONEDITIONABLE:
20499           case NOT:
20500           case NULL:
20501           case NULLIF:
20502           case OBJECT:
20503           case OID:
20504           case OPAQUE:
20505           case OPEN:
20506           case OPERATOR:
20507           case ORGANIZATION:
20508           case OTHERS:
20509           case OVERRIDING:
20510           case PACKAGE:
20511           case PARTITION:
20512           case PRESERVE:
20513           case PRIVATE:
20514           case PROCEDURE:
20515           case RANGE:
20516           case RAW:
20517           case REAL:
20518           case RECORD:
20519           case REF:
20520           case RELEASE:
20521           case RELIES_ON:
20522           case RENAME:
20523           case RESULT:
20524           case RETURN:
20525           case RETURNING:
20526           case REVERSE:
20527           case ROLLBACK:
20528           case ROW:
20529           case ROWS:
20530           case ROWID:
20531           case ROWNUM:
20532           case SAVE:
20533           case SAVEPOINT:
20534           case SECOND:
20535           case SELECT:
20536           case SELF:
20537           case SET:
20538           case SPACE:
20539           case SQL:
20540           case SQLCODE:
20541           case SQLERRM:
20542           case STATIC:
20543           case SUBTYPE:
20544           case SUBSTITUTABLE:
20545           case SUCCESSFUL:
20546           case SYSDATE:
20547           case SYS_REFCURSOR:
20548           case TEMPORARY:
20549           case TIME:
20550           case TIMESTAMP:
20551           case TIMEZONE_REGION:
20552           case TIMEZONE_ABBR:
20553           case TIMEZONE_MINUTE:
20554           case TIMEZONE_HOUR:
20555           case TRANSACTION:
20556           case TRUE:
20557           case TYPE:
20558           case UNDER:
20559           case USING:
20560           case YES:
20561           case SHOW:
20562           case A:
20563           case DOUBLE:
20564           case DEC:
20565           case PRECISION:
20566           case INT:
20567           case NUMERIC:
20568           case NCHAR:
20569           case NVARCHAR2:
20570           case STRING:
20571           case UROWID:
20572           case VARRAY:
20573           case VARYING:
20574           case BFILE:
20575           case BLOB:
20576           case CLOB:
20577           case NCLOB:
20578           case YEAR:
20579           case LOCAL:
20580           case WITH:
20581           case ZONE:
20582           case CHARACTER:
20583           case AFTER:
20584           case BEFORE:
20585           case OLD:
20586           case PARENT:
20587           case CC_IF:
20588           case ANALYZE:
20589           case ASSOCIATE:
20590           case AUDIT:
20591           case COMPOUND:
20592           case DATABASE:
20593           case CALL:
20594           case DDL:
20595           case DISASSOCIATE:
20596           case EACH:
20597           case FOLLOWS:
20598           case LOGOFF:
20599           case LOGON:
20600           case NESTED:
20601           case NOAUDIT:
20602           case SCHEMA:
20603           case SERVERERROR:
20604           case SHUTDOWN:
20605           case STARTUP:
20606           case STATEMENT:
20607           case STATISTICS:
20608           case SUSPEND:
20609           case TRUNCATE:
20610           case WRAPPED:
20611           case LIBRARY:
20612           case NAME:
20613           case STRUCT:
20614           case CONTEXT:
20615           case PARAMETERS:
20616           case LENGTH:
20617           case TDO:
20618           case MAXLEN:
20619           case CHARSETID:
20620           case CHARSETFORM:
20621           case ACCEPT:
20622           case ACCESSIBLE:
20623           case COPY:
20624           case DEFINE:
20625           case DISCONNECT:
20626           case HOST:
20627           case PRINT:
20628           case QUIT:
20629           case REMARK:
20630           case UNDEFINE:
20631           case VARIABLE:
20632           case WHENEVER:
20633           case ATTACH:
20634           case CAST:
20635           case TREAT:
20636           case TRIM:
20637           case LEFT:
20638           case RIGHT:
20639           case BOTH:
20640           case EMPTY:
20641           case MULTISET:
20642           case SUBMULTISET:
20643           case LEADING:
20644           case TRAILING:
20645           case CHAR_CS:
20646           case NCHAR_CS:
20647           case AUTHENTICATED:
20648           case LINK:
20649           case SHARED:
20650           case DIRECTORY:
20651           case USER:
20652           case IDENTIFIER:
20653           case UNSIGNED_NUMERIC_LITERAL:
20654           case CHARACTER_LITERAL:
20655           case QUOTED_LITERAL:
20656             suffixNode = Expression();
20657                                                sb.append(" "); sb.append(suffixNode.toString());
20658             break;
20659           default:
20660             jj_la1[268] = jj_gen;
20661             jj_consume_token(-1);
20662             throw new ParseException();
20663           }
20664           break;
20665         default:
20666           jj_la1[269] = jj_gen;
20667           jj_consume_token(-1);
20668           throw new ParseException();
20669         }
20670         break;
20671       case 5:
20672         arguments = Arguments();
20673                                sb.append(arguments) ;
20674         break;
20675       default:
20676         jj_la1[270] = jj_gen;
20677         jj_consume_token(-1);
20678         throw new ParseException();
20679       }
20680    jjtree.closeNodeScope(jjtn000, true);
20681    jjtc000 = false;
20682  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20683     } catch (Throwable jjte000) {
20684     if (jjtc000) {
20685       jjtree.clearNodeScope(jjtn000);
20686       jjtc000 = false;
20687     } else {
20688       jjtree.popNode();
20689     }
20690     if (jjte000 instanceof RuntimeException) {
20691       {if (true) throw (RuntimeException)jjte000;}
20692     }
20693     if (jjte000 instanceof ParseException) {
20694       {if (true) throw (ParseException)jjte000;}
20695     }
20696     {if (true) throw (Error)jjte000;}
20697     } finally {
20698     if (jjtc000) {
20699       jjtree.closeNodeScope(jjtn000, true);
20700     }
20701     }
20702     throw new Error("Missing return statement in function");
20703   }
20704 
20705   final public ASTLiteral Literal() throws ParseException {
20706  /*@bgen(jjtree) Literal */
20707  ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
20708  boolean jjtc000 = true;
20709  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20710  Token t = null ;
20711     try {
20712       switch (jj_nt.kind) {
20713       case UNSIGNED_NUMERIC_LITERAL:
20714         simpleNode = NumericLiteral();
20715         break;
20716       case CHARACTER_LITERAL:
20717         t = jj_consume_token(CHARACTER_LITERAL);
20718         break;
20719       case STRING_LITERAL:
20720         //<STRING_LITERAL> {literal = token.toString(); }
20721           simpleNode = StringLiteral();
20722         break;
20723       case FALSE:
20724       case TRUE:
20725         simpleNode = BooleanLiteral();
20726         break;
20727       case NULL:
20728         simpleNode = NullLiteral();
20729         break;
20730       case DATE:
20731       case INTERVAL:
20732       case TIMESTAMP:
20733         simpleNode = DateTimeLiteral();
20734         break;
20735       default:
20736         jj_la1[271] = jj_gen;
20737         jj_consume_token(-1);
20738         throw new ParseException();
20739       }
20740    jjtree.closeNodeScope(jjtn000, true);
20741    jjtc000 = false;
20742    if (null != simpleNode)
20743    {
20744      jjtn000.setImage( simpleNode.getImage() ) ;
20745    }
20746    else if (null != t)
20747    {
20748      jjtn000.setImage( t.image ) ;
20749    }
20750    {if (true) return jjtn000 ;}
20751     } catch (Throwable jjte000) {
20752     if (jjtc000) {
20753       jjtree.clearNodeScope(jjtn000);
20754       jjtc000 = false;
20755     } else {
20756       jjtree.popNode();
20757     }
20758     if (jjte000 instanceof RuntimeException) {
20759       {if (true) throw (RuntimeException)jjte000;}
20760     }
20761     if (jjte000 instanceof ParseException) {
20762       {if (true) throw (ParseException)jjte000;}
20763     }
20764     {if (true) throw (Error)jjte000;}
20765     } finally {
20766     if (jjtc000) {
20767       jjtree.closeNodeScope(jjtn000, true);
20768     }
20769     }
20770     throw new Error("Missing return statement in function");
20771   }
20772 
20773   final public ASTStringLiteral StringLiteral() throws ParseException {
20774  /*@bgen(jjtree) StringLiteral */
20775         ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20776         boolean jjtc000 = true;
20777         jjtree.openNodeScope(jjtn000);Token thisToken = null;
20778         StringBuilder literal = new StringBuilder() ;
20779         char startDelimiter ;
20780         char endDelimiter ;
20781         String terminator = null;
20782     try {
20783       thisToken = jj_consume_token(STRING_LITERAL);
20784    literal.append(thisToken.image);
20785    /*
20786    This might be Q-Quoted string and this might be only a partial string
20787    The token will only match up to the first single quote.
20788    The code below appends any remaining part, theh returns the complete string
20789    */
20790    if (thisToken.image.toUpperCase().startsWith("Q'")
20791        && thisToken.image.length() > 2
20792       )
20793    {
20794    // Get the first token of the string so that the delimiter can be identified
20795 
20796      startDelimiter= thisToken.image.charAt(2) ;
20797      /*
20798      if the start delimiter is one of [, {, <, or (, the end delimiter
20799      is the corresponding closing character
20800      */
20801      switch (startDelimiter)
20802      {
20803       case '<' : endDelimiter = '>' ; break ;
20804       case '{' : endDelimiter = '}' ;  break ;
20805       case '(' : endDelimiter = ')' ;  break ;
20806       case '[' : endDelimiter = ']' ;  break ;
20807       default: endDelimiter = startDelimiter ;
20808      }
20809 
20810      terminator = new String(endDelimiter + "'");
20811      if (!thisToken.image.endsWith(terminator))
20812      {
20813        //Loop until we find atoken that ends with a single-quote precede by the terminator
20814        literal.append(ReadPastNextOccurrence(terminator));
20815      }
20816    }
20817    jjtree.closeNodeScope(jjtn000, true);
20818    jjtc000 = false;
20819    jjtn000.setImage(literal.toString()) ;  jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20820     } finally {
20821    if (jjtc000) {
20822      jjtree.closeNodeScope(jjtn000, true);
20823    }
20824     }
20825     throw new Error("Missing return statement in function");
20826   }
20827 
20828   final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20829  /*@bgen(jjtree) BooleanLiteral */
20830   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20831   boolean jjtc000 = true;
20832   jjtree.openNodeScope(jjtn000);
20833     try {
20834       switch (jj_nt.kind) {
20835       case TRUE:
20836         jj_consume_token(TRUE);
20837         break;
20838       case FALSE:
20839         jj_consume_token(FALSE);
20840         break;
20841       default:
20842         jj_la1[272] = jj_gen;
20843         jj_consume_token(-1);
20844         throw new ParseException();
20845       }
20846     jjtree.closeNodeScope(jjtn000, true);
20847     jjtc000 = false;
20848    jjtn000.setImage(token.image) ;
20849    {if (true) return jjtn000;}
20850     } finally {
20851    if (jjtc000) {
20852      jjtree.closeNodeScope(jjtn000, true);
20853    }
20854     }
20855     throw new Error("Missing return statement in function");
20856   }
20857 
20858   final public ASTNullLiteral NullLiteral() throws ParseException {
20859  /*@bgen(jjtree) NullLiteral */
20860   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20861   boolean jjtc000 = true;
20862   jjtree.openNodeScope(jjtn000);
20863     try {
20864       jj_consume_token(NULL);
20865    jjtree.closeNodeScope(jjtn000, true);
20866    jjtc000 = false;
20867   jjtn000.setImage(token.image) ;
20868   {if (true) return jjtn000 ;}
20869     } finally {
20870     if (jjtc000) {
20871       jjtree.closeNodeScope(jjtn000, true);
20872     }
20873     }
20874     throw new Error("Missing return statement in function");
20875   }
20876 
20877   final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20878  /*@bgen(jjtree) MultiSetCondition */
20879   ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20880   boolean jjtc000 = true;
20881   jjtree.openNodeScope(jjtn000);
20882     try {
20883       switch (jj_nt.kind) {
20884       case A:
20885         jj_consume_token(A);
20886         jj_consume_token(SET);
20887         break;
20888       case EMPTY:
20889         jj_consume_token(EMPTY);
20890         break;
20891       default:
20892         jj_la1[273] = jj_gen;
20893         jj_consume_token(-1);
20894         throw new ParseException();
20895       }
20896    jjtree.closeNodeScope(jjtn000, true);
20897    jjtc000 = false;
20898   {if (true) return jjtn000;}
20899     } finally {
20900     if (jjtc000) {
20901       jjtree.closeNodeScope(jjtn000, true);
20902     }
20903     }
20904     throw new Error("Missing return statement in function");
20905   }
20906 
20907 /** Recognizes a numeric literal.
20908 * This may look like token, but it isn't. Not atomic enough.
20909 * E.g. "+1" would be valid literal, which make parsing of "i+1" impossible
20910 * (here, we have tokens "i", "+" and "1")
20911 */
20912   final public ASTNumericLiteral NumericLiteral() throws ParseException {
20913  /*@bgen(jjtree) NumericLiteral */
20914  ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20915  boolean jjtc000 = true;
20916  jjtree.openNodeScope(jjtn000);Token t = null ;
20917     try {
20918       //Essentially unchanged, as it previouly returned a Token 
20919                       t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20920           jjtree.closeNodeScope(jjtn000, true);
20921           jjtc000 = false;
20922          jjtn000.setImage(t.image) ;
20923          {if (true) return jjtn000;}
20924     } finally {
20925           if (jjtc000) {
20926             jjtree.closeNodeScope(jjtn000, true);
20927           }
20928     }
20929     throw new Error("Missing return statement in function");
20930   }
20931 
20932 /** This cannot be a token because these are valid labels '&lt;&lt; next_msg &gt;&gt;", '&lt;&lt;"OUTER LOOP"&gt;&gt;'
20933 */
20934   final public ASTLabel Label() throws ParseException {
20935  /*@bgen(jjtree) Label */
20936  ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20937  boolean jjtc000 = true;
20938  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20939     try {
20940       jj_consume_token(21);
20941       simpleNode = UnqualifiedID();
20942       jj_consume_token(22);
20943           jjtree.closeNodeScope(jjtn000, true);
20944           jjtc000 = false;
20945         jjtn000.setImage( simpleNode.getImage() ) ;
20946         {if (true) return jjtn000;}
20947     } catch (Throwable jjte000) {
20948           if (jjtc000) {
20949             jjtree.clearNodeScope(jjtn000);
20950             jjtc000 = false;
20951           } else {
20952             jjtree.popNode();
20953           }
20954           if (jjte000 instanceof RuntimeException) {
20955             {if (true) throw (RuntimeException)jjte000;}
20956           }
20957           if (jjte000 instanceof ParseException) {
20958             {if (true) throw (ParseException)jjte000;}
20959           }
20960           {if (true) throw (Error)jjte000;}
20961     } finally {
20962           if (jjtc000) {
20963             jjtree.closeNodeScope(jjtn000, true);
20964           }
20965     }
20966     throw new Error("Missing return statement in function");
20967   }
20968 
20969   final public ASTName Name() throws ParseException {
20970  /*@bgen(jjtree) Name */
20971  ASTName jjtn000 = new ASTName(this, JJTNAME);
20972  boolean jjtc000 = true;
20973  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20974  StringBuilder sb = new StringBuilder();
20975     try {
20976       simpleNode = UnqualifiedID();
20977                                    sb.append(simpleNode.getImage()) ;
20978       label_64:
20979       while (true) {
20980         if (jj_2_58(2)) {
20981           ;
20982         } else {
20983           break label_64;
20984         }
20985         switch (jj_nt.kind) {
20986         case 3:
20987           jj_consume_token(3);
20988             sb.append(".") ;
20989           break;
20990         case 11:
20991           jj_consume_token(11);
20992                                        sb.append("%") ;
20993           break;
20994         default:
20995           jj_la1[274] = jj_gen;
20996           jj_consume_token(-1);
20997           throw new ParseException();
20998         }
20999         //QualifiedID() 
21000             simpleNode = QualifiedID();
21001                                   sb.append(simpleNode.getImage()) ;
21002       }
21003     jjtree.closeNodeScope(jjtn000, true);
21004     jjtc000 = false;
21005   jjtn000.setImage(sb.toString()) ;
21006   {if (true) return jjtn000;}
21007     } catch (Throwable jjte000) {
21008     if (jjtc000) {
21009       jjtree.clearNodeScope(jjtn000);
21010       jjtc000 = false;
21011     } else {
21012       jjtree.popNode();
21013     }
21014     if (jjte000 instanceof RuntimeException) {
21015       {if (true) throw (RuntimeException)jjte000;}
21016     }
21017     if (jjte000 instanceof ParseException) {
21018       {if (true) throw (ParseException)jjte000;}
21019     }
21020     {if (true) throw (Error)jjte000;}
21021     } finally {
21022     if (jjtc000) {
21023       jjtree.closeNodeScope(jjtn000, true);
21024     }
21025     }
21026     throw new Error("Missing return statement in function");
21027   }
21028 
21029   final public ASTQualifiedName QualifiedName() throws ParseException {
21030  /*@bgen(jjtree) QualifiedName */
21031  ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
21032  boolean jjtc000 = true;
21033  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21034  StringBuilder sb = new StringBuilder();
21035     try {
21036       simpleNode = UnqualifiedID();
21037                                         sb.append(simpleNode.getImage()) ;
21038       label_65:
21039       while (true) {
21040         switch (jj_nt.kind) {
21041         case 3:
21042           ;
21043           break;
21044         default:
21045           jj_la1[275] = jj_gen;
21046           break label_65;
21047         }
21048         jj_consume_token(3);
21049         simpleNode = QualifiedID();
21050                                               sb.append(".") ; sb.append(simpleNode.getImage()) ;
21051       }
21052           jjtree.closeNodeScope(jjtn000, true);
21053           jjtc000 = false;
21054          jjtn000.setImage(sb.toString()) ;
21055          {if (true) return jjtn000 ;}
21056     } catch (Throwable jjte000) {
21057           if (jjtc000) {
21058             jjtree.clearNodeScope(jjtn000);
21059             jjtc000 = false;
21060           } else {
21061             jjtree.popNode();
21062           }
21063           if (jjte000 instanceof RuntimeException) {
21064             {if (true) throw (RuntimeException)jjte000;}
21065           }
21066           if (jjte000 instanceof ParseException) {
21067             {if (true) throw (ParseException)jjte000;}
21068           }
21069           {if (true) throw (Error)jjte000;}
21070     } finally {
21071           if (jjtc000) {
21072             jjtree.closeNodeScope(jjtn000, true);
21073           }
21074     }
21075     throw new Error("Missing return statement in function");
21076   }
21077 
21078   final public ASTArguments Arguments() throws ParseException {
21079  /*@bgen(jjtree) Arguments */
21080   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
21081   boolean jjtc000 = true;
21082   jjtree.openNodeScope(jjtn000);
21083     try {
21084       jj_consume_token(5);
21085       switch (jj_nt.kind) {
21086       case 5:
21087       case 16:
21088       case 17:
21089       case REPLACE:
21090       case DEFINER:
21091       case CURRENT_USER:
21092       case LANGUAGE:
21093       case INLINE:
21094       case ADD:
21095       case AGGREGATE:
21096       case ARRAY:
21097       case AT:
21098       case ATTRIBUTE:
21099       case AUTHID:
21100       case BODY:
21101       case BULK:
21102       case BYTE:
21103       case CASCADE:
21104       case CASE:
21105       case CLOSE:
21106       case COALESCE:
21107       case COLLECT:
21108       case COLUMN:
21109       case COMMENT:
21110       case COMMIT:
21111       case CONSTRUCTOR:
21112       case CONTINUE:
21113       case CONVERT:
21114       case CURRENT:
21115       case CURSOR:
21116       case DATA:
21117       case DATE:
21118       case DAY:
21119       case DISABLE:
21120       case EDITIONABLE:
21121       case ELEMENT:
21122       case ENABLE:
21123       case ESCAPE:
21124       case EXCEPT:
21125       case EXCEPTIONS:
21126       case EXIT:
21127       case EXTERNAL:
21128       case EXTENDS:
21129       case EXTRACT:
21130       case FALSE:
21131       case FINAL:
21132       case FORCE:
21133       case FUNCTION:
21134       case GLOBAL:
21135       case HASH:
21136       case HEAP:
21137       case HOUR:
21138       case IMMEDIATE:
21139       case INDICES:
21140       case INDEXTYPE:
21141       case INDICATOR:
21142       case INSTANTIABLE:
21143       case INTERVAL:
21144       case INVALIDATE:
21145       case ISOLATION:
21146       case JAVA:
21147       case LEVEL:
21148       case LIMIT:
21149       case LOOP:
21150       case MAP:
21151       case MAX:
21152       case MEMBER:
21153       case MERGE:
21154       case MIN:
21155       case MINUTE:
21156       case MLSLABEL:
21157       case MODIFY:
21158       case MOD:
21159       case MONTH:
21160       case NATURAL:
21161       case NEW:
21162       case NEW_DOT:
21163       case NO:
21164       case NONEDITIONABLE:
21165       case NOT:
21166       case NULL:
21167       case NULLIF:
21168       case OBJECT:
21169       case OID:
21170       case OPAQUE:
21171       case OPEN:
21172       case OPERATOR:
21173       case ORGANIZATION:
21174       case OTHERS:
21175       case OVERRIDING:
21176       case PACKAGE:
21177       case PARTITION:
21178       case PRESERVE:
21179       case PRIVATE:
21180       case PROCEDURE:
21181       case RANGE:
21182       case RAW:
21183       case REAL:
21184       case RECORD:
21185       case REF:
21186       case RELEASE:
21187       case RELIES_ON:
21188       case RENAME:
21189       case RESULT:
21190       case RETURN:
21191       case RETURNING:
21192       case REVERSE:
21193       case ROLLBACK:
21194       case ROW:
21195       case ROWS:
21196       case ROWID:
21197       case ROWNUM:
21198       case SAVE:
21199       case SAVEPOINT:
21200       case SECOND:
21201       case SELECT:
21202       case SELF:
21203       case SET:
21204       case SPACE:
21205       case SQL:
21206       case SQLCODE:
21207       case SQLERRM:
21208       case STATIC:
21209       case SUBTYPE:
21210       case SUBSTITUTABLE:
21211       case SUCCESSFUL:
21212       case SYSDATE:
21213       case SYS_REFCURSOR:
21214       case TEMPORARY:
21215       case TIME:
21216       case TIMESTAMP:
21217       case TIMEZONE_REGION:
21218       case TIMEZONE_ABBR:
21219       case TIMEZONE_MINUTE:
21220       case TIMEZONE_HOUR:
21221       case TRANSACTION:
21222       case TRUE:
21223       case TYPE:
21224       case UNDER:
21225       case USING:
21226       case YES:
21227       case SHOW:
21228       case A:
21229       case DOUBLE:
21230       case DEC:
21231       case PRECISION:
21232       case INT:
21233       case NUMERIC:
21234       case NCHAR:
21235       case NVARCHAR2:
21236       case STRING:
21237       case UROWID:
21238       case VARRAY:
21239       case VARYING:
21240       case BFILE:
21241       case BLOB:
21242       case CLOB:
21243       case NCLOB:
21244       case YEAR:
21245       case LOCAL:
21246       case WITH:
21247       case ZONE:
21248       case CHARACTER:
21249       case AFTER:
21250       case BEFORE:
21251       case OLD:
21252       case PARENT:
21253       case CC_IF:
21254       case ANALYZE:
21255       case ASSOCIATE:
21256       case AUDIT:
21257       case COMPOUND:
21258       case DATABASE:
21259       case CALL:
21260       case DDL:
21261       case DISASSOCIATE:
21262       case EACH:
21263       case FOLLOWS:
21264       case LOGOFF:
21265       case LOGON:
21266       case NESTED:
21267       case NOAUDIT:
21268       case SCHEMA:
21269       case SERVERERROR:
21270       case SHUTDOWN:
21271       case STARTUP:
21272       case STATEMENT:
21273       case STATISTICS:
21274       case SUSPEND:
21275       case TRUNCATE:
21276       case WRAPPED:
21277       case LIBRARY:
21278       case NAME:
21279       case STRUCT:
21280       case CONTEXT:
21281       case PARAMETERS:
21282       case LENGTH:
21283       case TDO:
21284       case MAXLEN:
21285       case CHARSETID:
21286       case CHARSETFORM:
21287       case ACCEPT:
21288       case ACCESSIBLE:
21289       case COPY:
21290       case DEFINE:
21291       case DISCONNECT:
21292       case HOST:
21293       case PRINT:
21294       case QUIT:
21295       case REMARK:
21296       case UNDEFINE:
21297       case VARIABLE:
21298       case WHENEVER:
21299       case ATTACH:
21300       case CAST:
21301       case TREAT:
21302       case TRIM:
21303       case LEFT:
21304       case RIGHT:
21305       case BOTH:
21306       case EMPTY:
21307       case MULTISET:
21308       case SUBMULTISET:
21309       case LEADING:
21310       case TRAILING:
21311       case CHAR_CS:
21312       case NCHAR_CS:
21313       case DBTIMEZONE:
21314       case SESSIONTIMEZONE:
21315       case AUTHENTICATED:
21316       case LINK:
21317       case SHARED:
21318       case DIRECTORY:
21319       case USER:
21320       case IDENTIFIER:
21321       case UNSIGNED_NUMERIC_LITERAL:
21322       case CHARACTER_LITERAL:
21323       case STRING_LITERAL:
21324       case QUOTED_LITERAL:
21325         ArgumentList();
21326         break;
21327       default:
21328         jj_la1[276] = jj_gen;
21329         ;
21330       }
21331       jj_consume_token(7);
21332    jjtree.closeNodeScope(jjtn000, true);
21333    jjtc000 = false;
21334  {if (true) return jjtn000 ;}
21335     } catch (Throwable jjte000) {
21336     if (jjtc000) {
21337       jjtree.clearNodeScope(jjtn000);
21338       jjtc000 = false;
21339     } else {
21340       jjtree.popNode();
21341     }
21342     if (jjte000 instanceof RuntimeException) {
21343       {if (true) throw (RuntimeException)jjte000;}
21344     }
21345     if (jjte000 instanceof ParseException) {
21346       {if (true) throw (ParseException)jjte000;}
21347     }
21348     {if (true) throw (Error)jjte000;}
21349     } finally {
21350     if (jjtc000) {
21351       jjtree.closeNodeScope(jjtn000, true);
21352     }
21353     }
21354     throw new Error("Missing return statement in function");
21355   }
21356 
21357   final public ASTArgumentList ArgumentList() throws ParseException {
21358  /*@bgen(jjtree) ArgumentList */
21359   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
21360   boolean jjtc000 = true;
21361   jjtree.openNodeScope(jjtn000);
21362     try {
21363       Argument();
21364       label_66:
21365       while (true) {
21366         switch (jj_nt.kind) {
21367         case 6:
21368           ;
21369           break;
21370         default:
21371           jj_la1[277] = jj_gen;
21372           break label_66;
21373         }
21374         jj_consume_token(6);
21375         Argument();
21376       }
21377    jjtree.closeNodeScope(jjtn000, true);
21378    jjtc000 = false;
21379  {if (true) return jjtn000 ;}
21380     } catch (Throwable jjte000) {
21381     if (jjtc000) {
21382       jjtree.clearNodeScope(jjtn000);
21383       jjtc000 = false;
21384     } else {
21385       jjtree.popNode();
21386     }
21387     if (jjte000 instanceof RuntimeException) {
21388       {if (true) throw (RuntimeException)jjte000;}
21389     }
21390     if (jjte000 instanceof ParseException) {
21391       {if (true) throw (ParseException)jjte000;}
21392     }
21393     {if (true) throw (Error)jjte000;}
21394     } finally {
21395     if (jjtc000) {
21396       jjtree.closeNodeScope(jjtn000, true);
21397     }
21398     }
21399     throw new Error("Missing return statement in function");
21400   }
21401 
21402   final public ASTArgument Argument() throws ParseException {
21403  /*@bgen(jjtree) Argument */
21404  ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
21405  boolean jjtc000 = true;
21406  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21407     try {
21408       if (jj_2_59(2)) {
21409         simpleNode = UnqualifiedID();
21410         switch (jj_nt.kind) {
21411         case 23:
21412           jj_consume_token(23);
21413           break;
21414         case AS:
21415           jj_consume_token(AS);
21416           break;
21417         default:
21418           jj_la1[278] = jj_gen;
21419           jj_consume_token(-1);
21420           throw new ParseException();
21421         }
21422       } else {
21423         ;
21424       }
21425       Expression();
21426       switch (jj_nt.kind) {
21427       case USING:
21428         jj_consume_token(USING);
21429         switch (jj_nt.kind) {
21430         case CHAR_CS:
21431           jj_consume_token(CHAR_CS);
21432           break;
21433         case NCHAR_CS:
21434           jj_consume_token(NCHAR_CS);
21435           break;
21436         default:
21437           jj_la1[279] = jj_gen;
21438           jj_consume_token(-1);
21439           throw new ParseException();
21440         }
21441         break;
21442       default:
21443         jj_la1[280] = jj_gen;
21444         ;
21445       }
21446    jjtree.closeNodeScope(jjtn000, true);
21447    jjtc000 = false;
21448  if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
21449  {if (true) return jjtn000 ;}
21450     } catch (Throwable jjte000) {
21451           if (jjtc000) {
21452             jjtree.clearNodeScope(jjtn000);
21453             jjtc000 = false;
21454           } else {
21455             jjtree.popNode();
21456           }
21457           if (jjte000 instanceof RuntimeException) {
21458             {if (true) throw (RuntimeException)jjte000;}
21459           }
21460           if (jjte000 instanceof ParseException) {
21461             {if (true) throw (ParseException)jjte000;}
21462           }
21463           {if (true) throw (Error)jjte000;}
21464     } finally {
21465           if (jjtc000) {
21466             jjtree.closeNodeScope(jjtn000, true);
21467           }
21468     }
21469     throw new Error("Missing return statement in function");
21470   }
21471 
21472 // ============================================================================
21473 // D E C L A R A T I O N S
21474 // ============================================================================
21475   final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
21476  /*@bgen(jjtree) VariableOrConstantDeclaration */
21477   ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
21478   boolean jjtc000 = true;
21479   jjtree.openNodeScope(jjtn000);
21480     try {
21481       VariableOrConstantDeclarator();
21482       jj_consume_token(4);
21483     jjtree.closeNodeScope(jjtn000, true);
21484     jjtc000 = false;
21485     {if (true) return jjtn000 ;}
21486     } catch (Throwable jjte000) {
21487     if (jjtc000) {
21488       jjtree.clearNodeScope(jjtn000);
21489       jjtc000 = false;
21490     } else {
21491       jjtree.popNode();
21492     }
21493     if (jjte000 instanceof RuntimeException) {
21494       {if (true) throw (RuntimeException)jjte000;}
21495     }
21496     if (jjte000 instanceof ParseException) {
21497       {if (true) throw (ParseException)jjte000;}
21498     }
21499     {if (true) throw (Error)jjte000;}
21500     } finally {
21501     if (jjtc000) {
21502       jjtree.closeNodeScope(jjtn000, true);
21503     }
21504     }
21505     throw new Error("Missing return statement in function");
21506   }
21507 
21508   final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
21509  /*@bgen(jjtree) DatatypeDeclaration */
21510  ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
21511  boolean jjtc000 = true;
21512  jjtree.openNodeScope(jjtn000);Token t ;
21513     try {
21514       t = jj_consume_token(IDENTIFIER);
21515     jjtree.closeNodeScope(jjtn000, true);
21516     jjtc000 = false;
21517     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
21518     } finally {
21519     if (jjtc000) {
21520       jjtree.closeNodeScope(jjtn000, true);
21521     }
21522     }
21523     throw new Error("Missing return statement in function");
21524   }
21525 
21526   final public ASTPragma Pragma() throws ParseException {
21527  /*@bgen(jjtree) Pragma */
21528   ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
21529   boolean jjtc000 = true;
21530   jjtree.openNodeScope(jjtn000);
21531     try {
21532       jj_consume_token(PRAGMA);
21533       switch (jj_nt.kind) {
21534       case SERIALLY_REUSABLE:
21535         jj_consume_token(SERIALLY_REUSABLE);
21536         break;
21537       case AUTONOMOUS_TRANSACTION:
21538         jj_consume_token(AUTONOMOUS_TRANSACTION);
21539         break;
21540       case TIMESTAMP:
21541         jj_consume_token(TIMESTAMP);
21542         jj_consume_token(5);
21543         StringLiteral();
21544         jj_consume_token(7);
21545         break;
21546       case RESTRICT_REFERENCES:
21547         jj_consume_token(RESTRICT_REFERENCES);
21548         jj_consume_token(5);
21549         ID();
21550         label_67:
21551         while (true) {
21552           jj_consume_token(6);
21553           switch (jj_nt.kind) {
21554           case REPLACE:
21555           case DEFINER:
21556           case CURRENT_USER:
21557           case SERIALLY_REUSABLE:
21558           case RESTRICT_REFERENCES:
21559           case EXCEPTION_INIT:
21560           case AUTONOMOUS_TRANSACTION:
21561           case LANGUAGE:
21562           case INLINE:
21563           case ADD:
21564           case AGGREGATE:
21565           case ALL:
21566           case ALTER:
21567           case AND:
21568           case ANY:
21569           case ARRAY:
21570           case AS:
21571           case ASC:
21572           case AT:
21573           case ATTRIBUTE:
21574           case AUTHID:
21575           case AVG:
21576           case BETWEEN:
21577           case BINARY_INTEGER:
21578           case BODY:
21579           case BOOLEAN:
21580           case BULK:
21581           case BY:
21582           case BYTE:
21583           case CASCADE:
21584           case CASE:
21585           case CHAR:
21586           case CHAR_BASE:
21587           case CHECK:
21588           case CLOSE:
21589           case CLUSTER:
21590           case COALESCE:
21591           case COLLECT:
21592           case COLUMN:
21593           case COMMENT:
21594           case COMMIT:
21595           case COMPRESS:
21596           case CONNECT:
21597           case CONSTANT:
21598           case CONSTRUCTOR:
21599           case CONTINUE:
21600           case CONVERT:
21601           case CREATE:
21602           case CURRENT:
21603           case CURRVAL:
21604           case CURSOR:
21605           case DATA:
21606           case DATE:
21607           case DAY:
21608           case DECLARE:
21609           case DECIMAL:
21610           case _DEFAULT:
21611           case DELETE:
21612           case DESC:
21613           case DISABLE:
21614           case DISTINCT:
21615           case DO:
21616           case DROP:
21617           case EDITIONABLE:
21618           case ELEMENT:
21619           case ELSE:
21620           case ELSIF:
21621           case ENABLE:
21622           case ESCAPE:
21623           case EXCEPT:
21624           case EXCEPTION:
21625           case EXCEPTIONS:
21626           case EXCLUSIVE:
21627           case EXECUTE:
21628           case EXISTS:
21629           case EXIT:
21630           case EXTERNAL:
21631           case EXTENDS:
21632           case EXTRACT:
21633           case FALSE:
21634           case FETCH:
21635           case FINAL:
21636           case FLOAT:
21637           case FOR:
21638           case FORALL:
21639           case FORCE:
21640           case FROM:
21641           case FUNCTION:
21642           case GLOBAL:
21643           case GOTO:
21644           case GROUP:
21645           case HASH:
21646           case HAVING:
21647           case HEAP:
21648           case HOUR:
21649           case IF:
21650           case IMMEDIATE:
21651           case IN:
21652           case INDEX:
21653           case INDICES:
21654           case INDEXTYPE:
21655           case INDICATOR:
21656           case INSERT:
21657           case INSTANTIABLE:
21658           case INTEGER:
21659           case INTERFACE:
21660           case INTERSECT:
21661           case INTERVAL:
21662           case INTO:
21663           case INVALIDATE:
21664           case IS:
21665           case ISOLATION:
21666           case JAVA:
21667           case LEVEL:
21668           case LIKE:
21669           case LIMIT:
21670           case LIMITED:
21671           case LOCK:
21672           case LONG:
21673           case LOOP:
21674           case MAP:
21675           case MAX:
21676           case MEMBER:
21677           case MERGE:
21678           case MIN:
21679           case MINUS:
21680           case MINUTE:
21681           case MLSLABEL:
21682           case MODIFY:
21683           case MOD:
21684           case MODE:
21685           case MONTH:
21686           case NATURAL:
21687           case NATURALN:
21688           case NEW:
21689           case NEXTVAL:
21690           case NO:
21691           case NOCOPY:
21692           case NONEDITIONABLE:
21693           case NOT:
21694           case NOWAIT:
21695           case NULL:
21696           case NULLIF:
21697           case NUMBER:
21698           case BFILE_BASE:
21699           case BLOB_BASE:
21700           case CLOB_BASE:
21701           case DATE_BASE:
21702           case NUMBER_BASE:
21703           case OBJECT:
21704           case OCIROWID:
21705           case OF:
21706           case OID:
21707           case ON:
21708           case OPAQUE:
21709           case OPEN:
21710           case OPERATOR:
21711           case OPTION:
21712           case OR:
21713           case ORDER:
21714           case ORGANIZATION:
21715           case OTHERS:
21716           case OUT:
21717           case OVERRIDING:
21718           case PACKAGE:
21719           case PARTITION:
21720           case PCTFREE:
21721           case PLS_INTEGER:
21722           case POSITIVE:
21723           case POSITIVEN:
21724           case PRESERVE:
21725           case PRIOR:
21726           case PROMPT:
21727           case PRIVATE:
21728           case PROCEDURE:
21729           case PUBLIC:
21730           case RAISE:
21731           case RANGE:
21732           case RAW:
21733           case REAL:
21734           case RECORD:
21735           case REF:
21736           case RELEASE:
21737           case RELIES_ON:
21738           case RENAME:
21739           case RESULT:
21740           case RETURN:
21741           case RETURNING:
21742           case REVERSE:
21743           case ROLLBACK:
21744           case ROW:
21745           case ROWS:
21746           case ROWID:
21747           case ROWNUM:
21748           case ROWTYPE:
21749           case SAVE:
21750           case SAVEPOINT:
21751           case SECOND:
21752           case SELECT:
21753           case SELF:
21754           case SEPARATE:
21755           case SET:
21756           case SHARE:
21757           case SMALLINT:
21758           case SPACE:
21759           case SQL:
21760           case SQLCODE:
21761           case SQLERRM:
21762           case START:
21763           case STATIC:
21764           case STDDEV:
21765           case SUBTYPE:
21766           case SUBSTITUTABLE:
21767           case SUCCESSFUL:
21768           case SUM:
21769           case SYNONYM:
21770           case SYSDATE:
21771           case SYS_REFCURSOR:
21772           case TABLE:
21773           case TEMPORARY:
21774           case THEN:
21775           case TIME:
21776           case TIMESTAMP:
21777           case TIMEZONE_REGION:
21778           case TIMEZONE_ABBR:
21779           case TIMEZONE_MINUTE:
21780           case TIMEZONE_HOUR:
21781           case TO:
21782           case TRANSACTION:
21783           case TRIGGER:
21784           case TRUE:
21785           case TYPE:
21786           case UI:
21787           case UNDER:
21788           case USING:
21789           case WHILE:
21790           case YES:
21791           case SHOW:
21792           case A:
21793           case UPDATE:
21794           case VARCHAR:
21795           case VARCHAR2:
21796           case DOUBLE:
21797           case DEC:
21798           case PRECISION:
21799           case INT:
21800           case NUMERIC:
21801           case SIGNTYPE:
21802           case NCHAR:
21803           case NVARCHAR2:
21804           case STRING:
21805           case UROWID:
21806           case VARRAY:
21807           case VARYING:
21808           case BFILE:
21809           case BLOB:
21810           case CLOB:
21811           case NCLOB:
21812           case YEAR:
21813           case LOCAL:
21814           case WITH:
21815           case ZONE:
21816           case CHARACTER:
21817           case AFTER:
21818           case BEFORE:
21819           case OLD:
21820           case PARENT:
21821           case ANALYZE:
21822           case ASSOCIATE:
21823           case AUDIT:
21824           case COMPOUND:
21825           case DATABASE:
21826           case CALL:
21827           case DDL:
21828           case DISASSOCIATE:
21829           case EACH:
21830           case FOLLOWS:
21831           case LOGOFF:
21832           case LOGON:
21833           case NESTED:
21834           case NOAUDIT:
21835           case SCHEMA:
21836           case SERVERERROR:
21837           case SHUTDOWN:
21838           case STARTUP:
21839           case STATEMENT:
21840           case STATISTICS:
21841           case SUSPEND:
21842           case TRUNCATE:
21843           case WRAPPED:
21844           case LIBRARY:
21845           case NAME:
21846           case STRUCT:
21847           case CONTEXT:
21848           case PARAMETERS:
21849           case LENGTH:
21850           case TDO:
21851           case MAXLEN:
21852           case CHARSETID:
21853           case CHARSETFORM:
21854           case ACCEPT:
21855           case ACCESSIBLE:
21856           case COPY:
21857           case DEFINE:
21858           case DISCONNECT:
21859           case HOST:
21860           case PRINT:
21861           case QUIT:
21862           case REMARK:
21863           case UNDEFINE:
21864           case VARIABLE:
21865           case WHENEVER:
21866           case ATTACH:
21867           case CAST:
21868           case TREAT:
21869           case TRIM:
21870           case LEFT:
21871           case RIGHT:
21872           case BOTH:
21873           case EMPTY:
21874           case MULTISET:
21875           case SUBMULTISET:
21876           case LEADING:
21877           case TRAILING:
21878           case CHAR_CS:
21879           case NCHAR_CS:
21880           case DBTIMEZONE:
21881           case SESSIONTIMEZONE:
21882           case AUTHENTICATED:
21883           case LINK:
21884           case SHARED:
21885           case DIRECTORY:
21886           case USER:
21887           case IDENTIFIER:
21888           case QUOTED_LITERAL:
21889           case SQLDATA_CLASS:
21890           case CUSTOMDATUM_CLASS:
21891           case ORADATA_CLASS:
21892           case JAVA_INTERFACE_CLASS:
21893             ID();
21894             break;
21895           case STRING_LITERAL:
21896             StringLiteral();
21897             break;
21898           default:
21899             jj_la1[281] = jj_gen;
21900             jj_consume_token(-1);
21901             throw new ParseException();
21902           }
21903           switch (jj_nt.kind) {
21904           case 6:
21905             ;
21906             break;
21907           default:
21908             jj_la1[282] = jj_gen;
21909             break label_67;
21910           }
21911         }
21912         jj_consume_token(7);
21913         break;
21914       case EXCEPTION_INIT:
21915         jj_consume_token(EXCEPTION_INIT);
21916         jj_consume_token(5);
21917         jj_consume_token(IDENTIFIER);
21918         jj_consume_token(6);
21919         switch (jj_nt.kind) {
21920         case 16:
21921         case 17:
21922           switch (jj_nt.kind) {
21923           case 16:
21924             jj_consume_token(16);
21925             break;
21926           case 17:
21927             jj_consume_token(17);
21928             break;
21929           default:
21930             jj_la1[283] = jj_gen;
21931             jj_consume_token(-1);
21932             throw new ParseException();
21933           }
21934           break;
21935         default:
21936           jj_la1[284] = jj_gen;
21937           ;
21938         }
21939         NumericLiteral();
21940         jj_consume_token(7);
21941         break;
21942       case INTERFACE:
21943         jj_consume_token(INTERFACE);
21944         jj_consume_token(5);
21945         jj_consume_token(IDENTIFIER);
21946         jj_consume_token(6);
21947         ID();
21948         switch (jj_nt.kind) {
21949         case 6:
21950           jj_consume_token(6);
21951           NumericLiteral();
21952           break;
21953         default:
21954           jj_la1[285] = jj_gen;
21955           ;
21956         }
21957         jj_consume_token(7);
21958         break;
21959       case REPLACE:
21960       case DEFINER:
21961       case CURRENT_USER:
21962       case LANGUAGE:
21963       case INLINE:
21964       case ADD:
21965       case AGGREGATE:
21966       case ARRAY:
21967       case AT:
21968       case ATTRIBUTE:
21969       case AUTHID:
21970       case BODY:
21971       case BULK:
21972       case BYTE:
21973       case CASCADE:
21974       case CLOSE:
21975       case COALESCE:
21976       case COLLECT:
21977       case COLUMN:
21978       case COMMENT:
21979       case COMMIT:
21980       case CONSTRUCTOR:
21981       case CONTINUE:
21982       case CONVERT:
21983       case CURRENT:
21984       case CURSOR:
21985       case DATA:
21986       case DAY:
21987       case DISABLE:
21988       case EDITIONABLE:
21989       case ELEMENT:
21990       case ENABLE:
21991       case ESCAPE:
21992       case EXCEPT:
21993       case EXCEPTIONS:
21994       case EXIT:
21995       case EXTERNAL:
21996       case EXTENDS:
21997       case EXTRACT:
21998       case FALSE:
21999       case FINAL:
22000       case FORCE:
22001       case FUNCTION:
22002       case GLOBAL:
22003       case HASH:
22004       case HEAP:
22005       case HOUR:
22006       case IMMEDIATE:
22007       case INDICES:
22008       case INDEXTYPE:
22009       case INDICATOR:
22010       case INSTANTIABLE:
22011       case INTERVAL:
22012       case INVALIDATE:
22013       case ISOLATION:
22014       case JAVA:
22015       case LEVEL:
22016       case LIMIT:
22017       case LOOP:
22018       case MAP:
22019       case MAX:
22020       case MEMBER:
22021       case MERGE:
22022       case MIN:
22023       case MINUTE:
22024       case MLSLABEL:
22025       case MODIFY:
22026       case MOD:
22027       case MONTH:
22028       case NATURAL:
22029       case NEW:
22030       case NO:
22031       case NONEDITIONABLE:
22032       case NULLIF:
22033       case OBJECT:
22034       case OID:
22035       case OPAQUE:
22036       case OPEN:
22037       case OPERATOR:
22038       case ORGANIZATION:
22039       case OTHERS:
22040       case OVERRIDING:
22041       case PACKAGE:
22042       case PARTITION:
22043       case PRESERVE:
22044       case PRIVATE:
22045       case PROCEDURE:
22046       case RANGE:
22047       case RAW:
22048       case REAL:
22049       case RECORD:
22050       case REF:
22051       case RELEASE:
22052       case RELIES_ON:
22053       case RENAME:
22054       case RESULT:
22055       case RETURN:
22056       case RETURNING:
22057       case REVERSE:
22058       case ROLLBACK:
22059       case ROW:
22060       case ROWS:
22061       case ROWID:
22062       case ROWNUM:
22063       case SAVE:
22064       case SAVEPOINT:
22065       case SECOND:
22066       case SELF:
22067       case SET:
22068       case SPACE:
22069       case SQL:
22070       case SQLCODE:
22071       case SQLERRM:
22072       case STATIC:
22073       case SUBTYPE:
22074       case SUBSTITUTABLE:
22075       case SUCCESSFUL:
22076       case SYSDATE:
22077       case SYS_REFCURSOR:
22078       case TEMPORARY:
22079       case TIME:
22080       case TIMEZONE_REGION:
22081       case TIMEZONE_ABBR:
22082       case TIMEZONE_MINUTE:
22083       case TIMEZONE_HOUR:
22084       case TRANSACTION:
22085       case TRUE:
22086       case TYPE:
22087       case UNDER:
22088       case USING:
22089       case YES:
22090       case SHOW:
22091       case A:
22092       case DOUBLE:
22093       case DEC:
22094       case PRECISION:
22095       case INT:
22096       case NUMERIC:
22097       case NCHAR:
22098       case NVARCHAR2:
22099       case STRING:
22100       case UROWID:
22101       case VARRAY:
22102       case VARYING:
22103       case BFILE:
22104       case BLOB:
22105       case CLOB:
22106       case NCLOB:
22107       case YEAR:
22108       case LOCAL:
22109       case ZONE:
22110       case CHARACTER:
22111       case AFTER:
22112       case BEFORE:
22113       case OLD:
22114       case PARENT:
22115       case ANALYZE:
22116       case ASSOCIATE:
22117       case AUDIT:
22118       case COMPOUND:
22119       case DATABASE:
22120       case CALL:
22121       case DDL:
22122       case DISASSOCIATE:
22123       case EACH:
22124       case FOLLOWS:
22125       case LOGOFF:
22126       case LOGON:
22127       case NESTED:
22128       case NOAUDIT:
22129       case SCHEMA:
22130       case SERVERERROR:
22131       case SHUTDOWN:
22132       case STARTUP:
22133       case STATEMENT:
22134       case STATISTICS:
22135       case SUSPEND:
22136       case TRUNCATE:
22137       case WRAPPED:
22138       case LIBRARY:
22139       case NAME:
22140       case STRUCT:
22141       case CONTEXT:
22142       case PARAMETERS:
22143       case LENGTH:
22144       case TDO:
22145       case MAXLEN:
22146       case CHARSETID:
22147       case CHARSETFORM:
22148       case ACCEPT:
22149       case ACCESSIBLE:
22150       case COPY:
22151       case DEFINE:
22152       case DISCONNECT:
22153       case HOST:
22154       case PRINT:
22155       case QUIT:
22156       case REMARK:
22157       case UNDEFINE:
22158       case VARIABLE:
22159       case WHENEVER:
22160       case ATTACH:
22161       case CAST:
22162       case TREAT:
22163       case TRIM:
22164       case LEFT:
22165       case RIGHT:
22166       case BOTH:
22167       case EMPTY:
22168       case MULTISET:
22169       case SUBMULTISET:
22170       case LEADING:
22171       case TRAILING:
22172       case CHAR_CS:
22173       case NCHAR_CS:
22174       case DBTIMEZONE:
22175       case SESSIONTIMEZONE:
22176       case AUTHENTICATED:
22177       case LINK:
22178       case SHARED:
22179       case DIRECTORY:
22180       case USER:
22181       case IDENTIFIER:
22182       case QUOTED_LITERAL:
22183         QualifiedName();
22184         jj_consume_token(5);
22185         ReadPastNextOccurrence(")");
22186         break;
22187       default:
22188         jj_la1[286] = jj_gen;
22189         jj_consume_token(-1);
22190         throw new ParseException();
22191       }
22192       jj_consume_token(4);
22193         jjtree.closeNodeScope(jjtn000, true);
22194         jjtc000 = false;
22195         {if (true) return jjtn000 ;}
22196     } catch (Throwable jjte000) {
22197           if (jjtc000) {
22198             jjtree.clearNodeScope(jjtn000);
22199             jjtc000 = false;
22200           } else {
22201             jjtree.popNode();
22202           }
22203           if (jjte000 instanceof RuntimeException) {
22204             {if (true) throw (RuntimeException)jjte000;}
22205           }
22206           if (jjte000 instanceof ParseException) {
22207             {if (true) throw (ParseException)jjte000;}
22208           }
22209           {if (true) throw (Error)jjte000;}
22210     } finally {
22211           if (jjtc000) {
22212             jjtree.closeNodeScope(jjtn000, true);
22213           }
22214     }
22215     throw new Error("Missing return statement in function");
22216   }
22217 
22218   final public ASTInlinePragma InlinePragma() throws ParseException {
22219  /*@bgen(jjtree) InlinePragma */
22220   ASTInlinePragma jjtn000 = new ASTInlinePragma(this, JJTINLINEPRAGMA);
22221   boolean jjtc000 = true;
22222   jjtree.openNodeScope(jjtn000);
22223     try {
22224       jj_consume_token(PRAGMA);
22225       jj_consume_token(INLINE);
22226       jj_consume_token(5);
22227       QualifiedName();
22228       jj_consume_token(6);
22229       StringLiteral();
22230       jj_consume_token(7);
22231         jjtree.closeNodeScope(jjtn000, true);
22232         jjtc000 = false;
22233         {if (true) return jjtn000 ;}
22234     } catch (Throwable jjte000) {
22235           if (jjtc000) {
22236             jjtree.clearNodeScope(jjtn000);
22237             jjtc000 = false;
22238           } else {
22239             jjtree.popNode();
22240           }
22241           if (jjte000 instanceof RuntimeException) {
22242             {if (true) throw (RuntimeException)jjte000;}
22243           }
22244           if (jjte000 instanceof ParseException) {
22245             {if (true) throw (ParseException)jjte000;}
22246           }
22247           {if (true) throw (Error)jjte000;}
22248     } finally {
22249           if (jjtc000) {
22250             jjtree.closeNodeScope(jjtn000, true);
22251           }
22252     }
22253     throw new Error("Missing return statement in function");
22254   }
22255 
22256   final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
22257  /*@bgen(jjtree) ExceptionDeclaration */
22258  ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
22259  boolean jjtc000 = true;
22260  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22261     try {
22262       simpleNode = ID();
22263       jj_consume_token(EXCEPTION);
22264       jj_consume_token(4);
22265         jjtree.closeNodeScope(jjtn000, true);
22266         jjtc000 = false;
22267         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22268     } catch (Throwable jjte000) {
22269           if (jjtc000) {
22270             jjtree.clearNodeScope(jjtn000);
22271             jjtc000 = false;
22272           } else {
22273             jjtree.popNode();
22274           }
22275           if (jjte000 instanceof RuntimeException) {
22276             {if (true) throw (RuntimeException)jjte000;}
22277           }
22278           if (jjte000 instanceof ParseException) {
22279             {if (true) throw (ParseException)jjte000;}
22280           }
22281           {if (true) throw (Error)jjte000;}
22282     } finally {
22283           if (jjtc000) {
22284             jjtree.closeNodeScope(jjtn000, true);
22285           }
22286     }
22287     throw new Error("Missing return statement in function");
22288   }
22289 
22290   final public ASTParallelClause ParallelClause() throws ParseException {
22291  /*@bgen(jjtree) ParallelClause */
22292   ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
22293   boolean jjtc000 = true;
22294   jjtree.openNodeScope(jjtn000);
22295     try {
22296       jj_consume_token(5);
22297       jj_consume_token(PARTITION);
22298       ID();
22299       jj_consume_token(BY);
22300       switch (jj_nt.kind) {
22301       case ANY:
22302         jj_consume_token(ANY);
22303         break;
22304       case HASH:
22305       case RANGE:
22306         switch (jj_nt.kind) {
22307         case HASH:
22308           jj_consume_token(HASH);
22309           break;
22310         case RANGE:
22311           jj_consume_token(RANGE);
22312           break;
22313         default:
22314           jj_la1[287] = jj_gen;
22315           jj_consume_token(-1);
22316           throw new ParseException();
22317         }
22318         jj_consume_token(5);
22319         ID();
22320         label_68:
22321         while (true) {
22322           switch (jj_nt.kind) {
22323           case 6:
22324             ;
22325             break;
22326           default:
22327             jj_la1[288] = jj_gen;
22328             break label_68;
22329           }
22330           jj_consume_token(6);
22331           ID();
22332         }
22333         jj_consume_token(7);
22334         break;
22335       default:
22336         jj_la1[289] = jj_gen;
22337         jj_consume_token(-1);
22338         throw new ParseException();
22339       }
22340       jj_consume_token(7);
22341       switch (jj_nt.kind) {
22342       case CLUSTER:
22343       case ORDER:
22344         switch (jj_nt.kind) {
22345         case ORDER:
22346           jj_consume_token(ORDER);
22347           break;
22348         case CLUSTER:
22349           jj_consume_token(CLUSTER);
22350           break;
22351         default:
22352           jj_la1[290] = jj_gen;
22353           jj_consume_token(-1);
22354           throw new ParseException();
22355         }
22356         jj_consume_token(BY);
22357         jj_consume_token(5);
22358         ID();
22359         label_69:
22360         while (true) {
22361           switch (jj_nt.kind) {
22362           case 6:
22363             ;
22364             break;
22365           default:
22366             jj_la1[291] = jj_gen;
22367             break label_69;
22368           }
22369           jj_consume_token(6);
22370           ID();
22371         }
22372         jj_consume_token(7);
22373         break;
22374       default:
22375         jj_la1[292] = jj_gen;
22376         ;
22377       }
22378         jjtree.closeNodeScope(jjtn000, true);
22379         jjtc000 = false;
22380         {if (true) return jjtn000 ;}
22381     } catch (Throwable jjte000) {
22382       if (jjtc000) {
22383         jjtree.clearNodeScope(jjtn000);
22384         jjtc000 = false;
22385       } else {
22386         jjtree.popNode();
22387       }
22388       if (jjte000 instanceof RuntimeException) {
22389         {if (true) throw (RuntimeException)jjte000;}
22390       }
22391       if (jjte000 instanceof ParseException) {
22392         {if (true) throw (ParseException)jjte000;}
22393       }
22394       {if (true) throw (Error)jjte000;}
22395     } finally {
22396       if (jjtc000) {
22397         jjtree.closeNodeScope(jjtn000, true);
22398       }
22399     }
22400     throw new Error("Missing return statement in function");
22401   }
22402 
22403   final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
22404  /*@bgen(jjtree) AccessibleByClause */
22405   ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
22406   boolean jjtc000 = true;
22407   jjtree.openNodeScope(jjtn000);
22408     try {
22409       jj_consume_token(ACCESSIBLE);
22410       jj_consume_token(BY);
22411       jj_consume_token(5);
22412       switch (jj_nt.kind) {
22413       case FUNCTION:
22414       case PACKAGE:
22415       case PROCEDURE:
22416       case TRIGGER:
22417       case TYPE:
22418         switch (jj_nt.kind) {
22419         case FUNCTION:
22420           jj_consume_token(FUNCTION);
22421           break;
22422         case PROCEDURE:
22423           jj_consume_token(PROCEDURE);
22424           break;
22425         case PACKAGE:
22426           jj_consume_token(PACKAGE);
22427           break;
22428         case TRIGGER:
22429           jj_consume_token(TRIGGER);
22430           break;
22431         case TYPE:
22432           jj_consume_token(TYPE);
22433           break;
22434         default:
22435           jj_la1[293] = jj_gen;
22436           jj_consume_token(-1);
22437           throw new ParseException();
22438         }
22439         break;
22440       default:
22441         jj_la1[294] = jj_gen;
22442         ;
22443       }
22444       QualifiedName();
22445       label_70:
22446       while (true) {
22447         switch (jj_nt.kind) {
22448         case 6:
22449           ;
22450           break;
22451         default:
22452           jj_la1[295] = jj_gen;
22453           break label_70;
22454         }
22455         jj_consume_token(6);
22456         switch (jj_nt.kind) {
22457         case FUNCTION:
22458         case PACKAGE:
22459         case PROCEDURE:
22460         case TRIGGER:
22461         case TYPE:
22462           switch (jj_nt.kind) {
22463           case FUNCTION:
22464             jj_consume_token(FUNCTION);
22465             break;
22466           case PROCEDURE:
22467             jj_consume_token(PROCEDURE);
22468             break;
22469           case PACKAGE:
22470             jj_consume_token(PACKAGE);
22471             break;
22472           case TRIGGER:
22473             jj_consume_token(TRIGGER);
22474             break;
22475           case TYPE:
22476             jj_consume_token(TYPE);
22477             break;
22478           default:
22479             jj_la1[296] = jj_gen;
22480             jj_consume_token(-1);
22481             throw new ParseException();
22482           }
22483           break;
22484         default:
22485           jj_la1[297] = jj_gen;
22486           ;
22487         }
22488         QualifiedName();
22489       }
22490       jj_consume_token(7);
22491         jjtree.closeNodeScope(jjtn000, true);
22492         jjtc000 = false;
22493         {if (true) return jjtn000 ;}
22494     } catch (Throwable jjte000) {
22495       if (jjtc000) {
22496         jjtree.clearNodeScope(jjtn000);
22497         jjtc000 = false;
22498       } else {
22499         jjtree.popNode();
22500       }
22501       if (jjte000 instanceof RuntimeException) {
22502         {if (true) throw (RuntimeException)jjte000;}
22503       }
22504       if (jjte000 instanceof ParseException) {
22505         {if (true) throw (ParseException)jjte000;}
22506       }
22507       {if (true) throw (Error)jjte000;}
22508     } finally {
22509       if (jjtc000) {
22510         jjtree.closeNodeScope(jjtn000, true);
22511       }
22512     }
22513     throw new Error("Missing return statement in function");
22514   }
22515 
22516 // Copyright (C) 2002 Albert Tumanov
22517 
22518 /**
22519  * 2006-05-10 - Matthias Hendler - merged SIV and sourceforge sources
22520  */
22521 
22522 // SRT *
22523   final public ASTTable Table() throws ParseException {
22524  /*@bgen(jjtree) Table */
22525   ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
22526   boolean jjtc000 = true;
22527   jjtree.openNodeScope(jjtn000);
22528     try {
22529       jj_consume_token(CREATE);
22530       switch (jj_nt.kind) {
22531       case GLOBAL:
22532         jj_consume_token(GLOBAL);
22533         jj_consume_token(TEMPORARY);
22534         break;
22535       default:
22536         jj_la1[298] = jj_gen;
22537         ;
22538       }
22539       jj_consume_token(TABLE);
22540       ObjectNameDeclaration();
22541       jj_consume_token(5);
22542       TableColumn();
22543       label_71:
22544       while (true) {
22545         switch (jj_nt.kind) {
22546         case 6:
22547           ;
22548           break;
22549         default:
22550           jj_la1[299] = jj_gen;
22551           break label_71;
22552         }
22553         jj_consume_token(6);
22554         TableColumn();
22555       }
22556       jj_consume_token(7);
22557       if (jj_2_60(2)) {
22558         jj_consume_token(ON);
22559         jj_consume_token(COMMIT);
22560         switch (jj_nt.kind) {
22561         case DELETE:
22562           jj_consume_token(DELETE);
22563           break;
22564         case PRESERVE:
22565           jj_consume_token(PRESERVE);
22566           break;
22567         default:
22568           jj_la1[300] = jj_gen;
22569           jj_consume_token(-1);
22570           throw new ParseException();
22571         }
22572         jj_consume_token(ROWS);
22573       } else {
22574         ;
22575       }
22576       switch (jj_nt.kind) {
22577       case 4:
22578         jj_consume_token(4);
22579         break;
22580       default:
22581         jj_la1[301] = jj_gen;
22582         ;
22583       }
22584         jjtree.closeNodeScope(jjtn000, true);
22585         jjtc000 = false;
22586         {if (true) return jjtn000 ;}
22587     } catch (Throwable jjte000) {
22588     if (jjtc000) {
22589       jjtree.clearNodeScope(jjtn000);
22590       jjtc000 = false;
22591     } else {
22592       jjtree.popNode();
22593     }
22594     if (jjte000 instanceof RuntimeException) {
22595       {if (true) throw (RuntimeException)jjte000;}
22596     }
22597     if (jjte000 instanceof ParseException) {
22598       {if (true) throw (ParseException)jjte000;}
22599     }
22600     {if (true) throw (Error)jjte000;}
22601     } finally {
22602     if (jjtc000) {
22603       jjtree.closeNodeScope(jjtn000, true);
22604     }
22605     }
22606     throw new Error("Missing return statement in function");
22607   }
22608 
22609   final public ASTTableColumn TableColumn() throws ParseException {
22610  /*@bgen(jjtree) TableColumn */
22611   ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
22612   boolean jjtc000 = true;
22613   jjtree.openNodeScope(jjtn000);
22614     try {
22615       ID();
22616       Datatype();
22617       switch (jj_nt.kind) {
22618       case _DEFAULT:
22619         jj_consume_token(_DEFAULT);
22620         Expression();
22621         break;
22622       default:
22623         jj_la1[302] = jj_gen;
22624         ;
22625       }
22626       switch (jj_nt.kind) {
22627       case NOT:
22628       case NULL:
22629         switch (jj_nt.kind) {
22630         case NOT:
22631           jj_consume_token(NOT);
22632           break;
22633         default:
22634           jj_la1[303] = jj_gen;
22635           ;
22636         }
22637         jj_consume_token(NULL);
22638         break;
22639       default:
22640         jj_la1[304] = jj_gen;
22641         ;
22642       }
22643         jjtree.closeNodeScope(jjtn000, true);
22644         jjtc000 = false;
22645         {if (true) return jjtn000 ;}
22646     } catch (Throwable jjte000) {
22647     if (jjtc000) {
22648       jjtree.clearNodeScope(jjtn000);
22649       jjtc000 = false;
22650     } else {
22651       jjtree.popNode();
22652     }
22653     if (jjte000 instanceof RuntimeException) {
22654       {if (true) throw (RuntimeException)jjte000;}
22655     }
22656     if (jjte000 instanceof ParseException) {
22657       {if (true) throw (ParseException)jjte000;}
22658     }
22659     {if (true) throw (Error)jjte000;}
22660     } finally {
22661     if (jjtc000) {
22662       jjtree.closeNodeScope(jjtn000, true);
22663     }
22664     }
22665     throw new Error("Missing return statement in function");
22666   }
22667 
22668   final public ASTView View() throws ParseException {
22669  /*@bgen(jjtree) View */
22670  ASTView jjtn000 = new ASTView(this, JJTVIEW);
22671  boolean jjtc000 = true;
22672  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22673     try {
22674       jj_consume_token(CREATE);
22675       switch (jj_nt.kind) {
22676       case OR:
22677         jj_consume_token(OR);
22678         jj_consume_token(REPLACE);
22679         break;
22680       default:
22681         jj_la1[305] = jj_gen;
22682         ;
22683       }
22684       switch (jj_nt.kind) {
22685       case FORCE:
22686       case NO:
22687         switch (jj_nt.kind) {
22688         case NO:
22689           jj_consume_token(NO);
22690           break;
22691         default:
22692           jj_la1[306] = jj_gen;
22693           ;
22694         }
22695         jj_consume_token(FORCE);
22696         break;
22697       default:
22698         jj_la1[307] = jj_gen;
22699         ;
22700       }
22701       jj_consume_token(VIEW);
22702       simpleNode = ObjectNameDeclaration();
22703       switch (jj_nt.kind) {
22704       case 5:
22705         jj_consume_token(5);
22706         ViewColumn();
22707         label_72:
22708         while (true) {
22709           switch (jj_nt.kind) {
22710           case 6:
22711             ;
22712             break;
22713           default:
22714             jj_la1[308] = jj_gen;
22715             break label_72;
22716           }
22717           jj_consume_token(6);
22718           ViewColumn();
22719         }
22720         jj_consume_token(7);
22721         break;
22722       default:
22723         jj_la1[309] = jj_gen;
22724         ;
22725       }
22726       jj_consume_token(AS);
22727       Statement();
22728       switch (jj_nt.kind) {
22729       case 4:
22730         jj_consume_token(4);
22731         break;
22732       case 1:
22733         jj_consume_token(1);
22734         break;
22735       default:
22736         jj_la1[310] = jj_gen;
22737         jj_consume_token(-1);
22738         throw new ParseException();
22739       }
22740     jjtree.closeNodeScope(jjtn000, true);
22741     jjtc000 = false;
22742     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22743     } catch (Throwable jjte000) {
22744     if (jjtc000) {
22745       jjtree.clearNodeScope(jjtn000);
22746       jjtc000 = false;
22747     } else {
22748       jjtree.popNode();
22749     }
22750     if (jjte000 instanceof RuntimeException) {
22751       {if (true) throw (RuntimeException)jjte000;}
22752     }
22753     if (jjte000 instanceof ParseException) {
22754       {if (true) throw (ParseException)jjte000;}
22755     }
22756     {if (true) throw (Error)jjte000;}
22757     } finally {
22758     if (jjtc000) {
22759       jjtree.closeNodeScope(jjtn000, true);
22760     }
22761     }
22762     throw new Error("Missing return statement in function");
22763   }
22764 
22765   final public ASTSynonym Synonym() throws ParseException {
22766  /*@bgen(jjtree) Synonym */
22767  ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
22768  boolean jjtc000 = true;
22769  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22770     try {
22771       jj_consume_token(CREATE);
22772       switch (jj_nt.kind) {
22773       case OR:
22774         jj_consume_token(OR);
22775         jj_consume_token(REPLACE);
22776         break;
22777       default:
22778         jj_la1[311] = jj_gen;
22779         ;
22780       }
22781       switch (jj_nt.kind) {
22782       case PUBLIC:
22783         jj_consume_token(PUBLIC);
22784         break;
22785       default:
22786         jj_la1[312] = jj_gen;
22787         ;
22788       }
22789       jj_consume_token(SYNONYM);
22790       simpleNode = ObjectNameDeclaration();
22791       jj_consume_token(FOR);
22792       ObjectNameDeclaration();
22793       switch (jj_nt.kind) {
22794       case 4:
22795         jj_consume_token(4);
22796         break;
22797       case 1:
22798         jj_consume_token(1);
22799         break;
22800       default:
22801         jj_la1[313] = jj_gen;
22802         jj_consume_token(-1);
22803         throw new ParseException();
22804       }
22805     jjtree.closeNodeScope(jjtn000, true);
22806     jjtc000 = false;
22807     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22808     } catch (Throwable jjte000) {
22809     if (jjtc000) {
22810       jjtree.clearNodeScope(jjtn000);
22811       jjtc000 = false;
22812     } else {
22813       jjtree.popNode();
22814     }
22815     if (jjte000 instanceof RuntimeException) {
22816       {if (true) throw (RuntimeException)jjte000;}
22817     }
22818     if (jjte000 instanceof ParseException) {
22819       {if (true) throw (ParseException)jjte000;}
22820     }
22821     {if (true) throw (Error)jjte000;}
22822     } finally {
22823     if (jjtc000) {
22824       jjtree.closeNodeScope(jjtn000, true);
22825     }
22826     }
22827     throw new Error("Missing return statement in function");
22828   }
22829 
22830   final public ASTDirectory Directory() throws ParseException {
22831  /*@bgen(jjtree) Directory */
22832  ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22833  boolean jjtc000 = true;
22834  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22835     try {
22836       jj_consume_token(CREATE);
22837       switch (jj_nt.kind) {
22838       case OR:
22839         jj_consume_token(OR);
22840         jj_consume_token(REPLACE);
22841         break;
22842       default:
22843         jj_la1[314] = jj_gen;
22844         ;
22845       }
22846       jj_consume_token(DIRECTORY);
22847       simpleNode = ObjectNameDeclaration();
22848       jj_consume_token(AS);
22849       StringLiteral();
22850       switch (jj_nt.kind) {
22851       case 4:
22852         jj_consume_token(4);
22853         break;
22854       case 1:
22855         jj_consume_token(1);
22856         break;
22857       default:
22858         jj_la1[315] = jj_gen;
22859         jj_consume_token(-1);
22860         throw new ParseException();
22861       }
22862     jjtree.closeNodeScope(jjtn000, true);
22863     jjtc000 = false;
22864     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22865     } catch (Throwable jjte000) {
22866     if (jjtc000) {
22867       jjtree.clearNodeScope(jjtn000);
22868       jjtc000 = false;
22869     } else {
22870       jjtree.popNode();
22871     }
22872     if (jjte000 instanceof RuntimeException) {
22873       {if (true) throw (RuntimeException)jjte000;}
22874     }
22875     if (jjte000 instanceof ParseException) {
22876       {if (true) throw (ParseException)jjte000;}
22877     }
22878     {if (true) throw (Error)jjte000;}
22879     } finally {
22880     if (jjtc000) {
22881       jjtree.closeNodeScope(jjtn000, true);
22882     }
22883     }
22884     throw new Error("Missing return statement in function");
22885   }
22886 
22887   final public ASTDatabaseLink DatabaseLink() throws ParseException {
22888  /*@bgen(jjtree) DatabaseLink */
22889  ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22890  boolean jjtc000 = true;
22891  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22892     try {
22893       jj_consume_token(CREATE);
22894       switch (jj_nt.kind) {
22895       case SHARED:
22896         jj_consume_token(SHARED);
22897         break;
22898       default:
22899         jj_la1[316] = jj_gen;
22900         ;
22901       }
22902       switch (jj_nt.kind) {
22903       case PUBLIC:
22904         jj_consume_token(PUBLIC);
22905         break;
22906       default:
22907         jj_la1[317] = jj_gen;
22908         ;
22909       }
22910       jj_consume_token(DATABASE);
22911       jj_consume_token(LINK);
22912       simpleNode = ObjectNameDeclaration();
22913       switch (jj_nt.kind) {
22914       case CONNECT:
22915         jj_consume_token(CONNECT);
22916         jj_consume_token(TO);
22917         switch (jj_nt.kind) {
22918         case CURRENT_USER:
22919           jj_consume_token(CURRENT_USER);
22920           break;
22921         case REPLACE:
22922         case DEFINER:
22923         case LANGUAGE:
22924         case INLINE:
22925         case ADD:
22926         case AGGREGATE:
22927         case ARRAY:
22928         case AT:
22929         case ATTRIBUTE:
22930         case AUTHID:
22931         case BODY:
22932         case BULK:
22933         case BYTE:
22934         case CASCADE:
22935         case CLOSE:
22936         case COALESCE:
22937         case COLLECT:
22938         case COLUMN:
22939         case COMMENT:
22940         case COMMIT:
22941         case CONSTRUCTOR:
22942         case CONTINUE:
22943         case CONVERT:
22944         case CURRENT:
22945         case CURSOR:
22946         case DATA:
22947         case DAY:
22948         case DISABLE:
22949         case EDITIONABLE:
22950         case ELEMENT:
22951         case ENABLE:
22952         case ESCAPE:
22953         case EXCEPT:
22954         case EXCEPTIONS:
22955         case EXIT:
22956         case EXTERNAL:
22957         case EXTENDS:
22958         case EXTRACT:
22959         case FALSE:
22960         case FINAL:
22961         case FORCE:
22962         case FUNCTION:
22963         case GLOBAL:
22964         case HASH:
22965         case HEAP:
22966         case HOUR:
22967         case IMMEDIATE:
22968         case INDICES:
22969         case INDEXTYPE:
22970         case INDICATOR:
22971         case INSTANTIABLE:
22972         case INTERVAL:
22973         case INVALIDATE:
22974         case ISOLATION:
22975         case JAVA:
22976         case LEVEL:
22977         case LIMIT:
22978         case LOOP:
22979         case MAP:
22980         case MAX:
22981         case MEMBER:
22982         case MERGE:
22983         case MIN:
22984         case MINUTE:
22985         case MLSLABEL:
22986         case MODIFY:
22987         case MOD:
22988         case MONTH:
22989         case NATURAL:
22990         case NEW:
22991         case NO:
22992         case NONEDITIONABLE:
22993         case NULLIF:
22994         case OBJECT:
22995         case OID:
22996         case OPAQUE:
22997         case OPEN:
22998         case OPERATOR:
22999         case ORGANIZATION:
23000         case OTHERS:
23001         case OVERRIDING:
23002         case PACKAGE:
23003         case PARTITION:
23004         case PRESERVE:
23005         case PRIVATE:
23006         case PROCEDURE:
23007         case RANGE:
23008         case RAW:
23009         case REAL:
23010         case RECORD:
23011         case REF:
23012         case RELEASE:
23013         case RELIES_ON:
23014         case RENAME:
23015         case RESULT:
23016         case RETURN:
23017         case RETURNING:
23018         case REVERSE:
23019         case ROLLBACK:
23020         case ROW:
23021         case ROWS:
23022         case ROWID:
23023         case ROWNUM:
23024         case SAVE:
23025         case SAVEPOINT:
23026         case SECOND:
23027         case SELF:
23028         case SET:
23029         case SPACE:
23030         case SQL:
23031         case SQLCODE:
23032         case SQLERRM:
23033         case STATIC:
23034         case SUBTYPE:
23035         case SUBSTITUTABLE:
23036         case SUCCESSFUL:
23037         case SYSDATE:
23038         case SYS_REFCURSOR:
23039         case TEMPORARY:
23040         case TIME:
23041         case TIMESTAMP:
23042         case TIMEZONE_REGION:
23043         case TIMEZONE_ABBR:
23044         case TIMEZONE_MINUTE:
23045         case TIMEZONE_HOUR:
23046         case TRANSACTION:
23047         case TRUE:
23048         case TYPE:
23049         case UNDER:
23050         case USING:
23051         case YES:
23052         case SHOW:
23053         case A:
23054         case DOUBLE:
23055         case DEC:
23056         case PRECISION:
23057         case INT:
23058         case NUMERIC:
23059         case NCHAR:
23060         case NVARCHAR2:
23061         case STRING:
23062         case UROWID:
23063         case VARRAY:
23064         case VARYING:
23065         case BFILE:
23066         case BLOB:
23067         case CLOB:
23068         case NCLOB:
23069         case YEAR:
23070         case LOCAL:
23071         case ZONE:
23072         case CHARACTER:
23073         case AFTER:
23074         case BEFORE:
23075         case OLD:
23076         case PARENT:
23077         case ANALYZE:
23078         case ASSOCIATE:
23079         case AUDIT:
23080         case COMPOUND:
23081         case DATABASE:
23082         case CALL:
23083         case DDL:
23084         case DISASSOCIATE:
23085         case EACH:
23086         case FOLLOWS:
23087         case LOGOFF:
23088         case LOGON:
23089         case NESTED:
23090         case NOAUDIT:
23091         case SCHEMA:
23092         case SERVERERROR:
23093         case SHUTDOWN:
23094         case STARTUP:
23095         case STATEMENT:
23096         case STATISTICS:
23097         case SUSPEND:
23098         case TRUNCATE:
23099         case WRAPPED:
23100         case LIBRARY:
23101         case NAME:
23102         case STRUCT:
23103         case CONTEXT:
23104         case PARAMETERS:
23105         case LENGTH:
23106         case TDO:
23107         case MAXLEN:
23108         case CHARSETID:
23109         case CHARSETFORM:
23110         case ACCEPT:
23111         case ACCESSIBLE:
23112         case COPY:
23113         case DEFINE:
23114         case DISCONNECT:
23115         case HOST:
23116         case PRINT:
23117         case QUIT:
23118         case REMARK:
23119         case UNDEFINE:
23120         case VARIABLE:
23121         case WHENEVER:
23122         case ATTACH:
23123         case CAST:
23124         case TREAT:
23125         case TRIM:
23126         case LEFT:
23127         case RIGHT:
23128         case BOTH:
23129         case EMPTY:
23130         case MULTISET:
23131         case SUBMULTISET:
23132         case LEADING:
23133         case TRAILING:
23134         case CHAR_CS:
23135         case NCHAR_CS:
23136         case DBTIMEZONE:
23137         case SESSIONTIMEZONE:
23138         case AUTHENTICATED:
23139         case LINK:
23140         case SHARED:
23141         case DIRECTORY:
23142         case USER:
23143         case IDENTIFIER:
23144         case QUOTED_LITERAL:
23145           UnqualifiedID();
23146           jj_consume_token(IDENTIFIED);
23147           jj_consume_token(BY);
23148           UnqualifiedID();
23149           jj_consume_token(AUTHENTICATED);
23150           jj_consume_token(BY);
23151           UnqualifiedID();
23152           jj_consume_token(IDENTIFIED);
23153           jj_consume_token(BY);
23154           UnqualifiedID();
23155           break;
23156         default:
23157           jj_la1[318] = jj_gen;
23158           jj_consume_token(-1);
23159           throw new ParseException();
23160         }
23161         break;
23162       case REPLACE:
23163       case DEFINER:
23164       case CURRENT_USER:
23165       case LANGUAGE:
23166       case INLINE:
23167       case ADD:
23168       case AGGREGATE:
23169       case ARRAY:
23170       case AT:
23171       case ATTRIBUTE:
23172       case AUTHID:
23173       case BODY:
23174       case BULK:
23175       case BYTE:
23176       case CASCADE:
23177       case CLOSE:
23178       case COALESCE:
23179       case COLLECT:
23180       case COLUMN:
23181       case COMMENT:
23182       case COMMIT:
23183       case CONSTRUCTOR:
23184       case CONTINUE:
23185       case CONVERT:
23186       case CURRENT:
23187       case CURSOR:
23188       case DATA:
23189       case DAY:
23190       case DISABLE:
23191       case EDITIONABLE:
23192       case ELEMENT:
23193       case ENABLE:
23194       case ESCAPE:
23195       case EXCEPT:
23196       case EXCEPTIONS:
23197       case EXIT:
23198       case EXTERNAL:
23199       case EXTENDS:
23200       case EXTRACT:
23201       case FALSE:
23202       case FINAL:
23203       case FORCE:
23204       case FUNCTION:
23205       case GLOBAL:
23206       case HASH:
23207       case HEAP:
23208       case HOUR:
23209       case IMMEDIATE:
23210       case INDICES:
23211       case INDEXTYPE:
23212       case INDICATOR:
23213       case INSTANTIABLE:
23214       case INTERVAL:
23215       case INVALIDATE:
23216       case ISOLATION:
23217       case JAVA:
23218       case LEVEL:
23219       case LIMIT:
23220       case LOOP:
23221       case MAP:
23222       case MAX:
23223       case MEMBER:
23224       case MERGE:
23225       case MIN:
23226       case MINUTE:
23227       case MLSLABEL:
23228       case MODIFY:
23229       case MOD:
23230       case MONTH:
23231       case NATURAL:
23232       case NEW:
23233       case NO:
23234       case NONEDITIONABLE:
23235       case NULLIF:
23236       case OBJECT:
23237       case OID:
23238       case OPAQUE:
23239       case OPEN:
23240       case OPERATOR:
23241       case ORGANIZATION:
23242       case OTHERS:
23243       case OVERRIDING:
23244       case PACKAGE:
23245       case PARTITION:
23246       case PRESERVE:
23247       case PRIVATE:
23248       case PROCEDURE:
23249       case RANGE:
23250       case RAW:
23251       case REAL:
23252       case RECORD:
23253       case REF:
23254       case RELEASE:
23255       case RELIES_ON:
23256       case RENAME:
23257       case RESULT:
23258       case RETURN:
23259       case RETURNING:
23260       case REVERSE:
23261       case ROLLBACK:
23262       case ROW:
23263       case ROWS:
23264       case ROWID:
23265       case ROWNUM:
23266       case SAVE:
23267       case SAVEPOINT:
23268       case SECOND:
23269       case SELF:
23270       case SET:
23271       case SPACE:
23272       case SQL:
23273       case SQLCODE:
23274       case SQLERRM:
23275       case STATIC:
23276       case SUBTYPE:
23277       case SUBSTITUTABLE:
23278       case SUCCESSFUL:
23279       case SYSDATE:
23280       case SYS_REFCURSOR:
23281       case TEMPORARY:
23282       case TIME:
23283       case TIMESTAMP:
23284       case TIMEZONE_REGION:
23285       case TIMEZONE_ABBR:
23286       case TIMEZONE_MINUTE:
23287       case TIMEZONE_HOUR:
23288       case TRANSACTION:
23289       case TRUE:
23290       case TYPE:
23291       case UNDER:
23292       case USING:
23293       case YES:
23294       case SHOW:
23295       case A:
23296       case DOUBLE:
23297       case DEC:
23298       case PRECISION:
23299       case INT:
23300       case NUMERIC:
23301       case NCHAR:
23302       case NVARCHAR2:
23303       case STRING:
23304       case UROWID:
23305       case VARRAY:
23306       case VARYING:
23307       case BFILE:
23308       case BLOB:
23309       case CLOB:
23310       case NCLOB:
23311       case YEAR:
23312       case LOCAL:
23313       case ZONE:
23314       case CHARACTER:
23315       case AFTER:
23316       case BEFORE:
23317       case OLD:
23318       case PARENT:
23319       case ANALYZE:
23320       case ASSOCIATE:
23321       case AUDIT:
23322       case COMPOUND:
23323       case DATABASE:
23324       case CALL:
23325       case DDL:
23326       case DISASSOCIATE:
23327       case EACH:
23328       case FOLLOWS:
23329       case LOGOFF:
23330       case LOGON:
23331       case NESTED:
23332       case NOAUDIT:
23333       case SCHEMA:
23334       case SERVERERROR:
23335       case SHUTDOWN:
23336       case STARTUP:
23337       case STATEMENT:
23338       case STATISTICS:
23339       case SUSPEND:
23340       case TRUNCATE:
23341       case WRAPPED:
23342       case LIBRARY:
23343       case NAME:
23344       case STRUCT:
23345       case CONTEXT:
23346       case PARAMETERS:
23347       case LENGTH:
23348       case TDO:
23349       case MAXLEN:
23350       case CHARSETID:
23351       case CHARSETFORM:
23352       case ACCEPT:
23353       case ACCESSIBLE:
23354       case COPY:
23355       case DEFINE:
23356       case DISCONNECT:
23357       case HOST:
23358       case PRINT:
23359       case QUIT:
23360       case REMARK:
23361       case UNDEFINE:
23362       case VARIABLE:
23363       case WHENEVER:
23364       case ATTACH:
23365       case CAST:
23366       case TREAT:
23367       case TRIM:
23368       case LEFT:
23369       case RIGHT:
23370       case BOTH:
23371       case EMPTY:
23372       case MULTISET:
23373       case SUBMULTISET:
23374       case LEADING:
23375       case TRAILING:
23376       case CHAR_CS:
23377       case NCHAR_CS:
23378       case DBTIMEZONE:
23379       case SESSIONTIMEZONE:
23380       case AUTHENTICATED:
23381       case LINK:
23382       case SHARED:
23383       case DIRECTORY:
23384       case USER:
23385       case IDENTIFIER:
23386       case QUOTED_LITERAL:
23387         UnqualifiedID();
23388         jj_consume_token(IDENTIFIED);
23389         jj_consume_token(BY);
23390         UnqualifiedID();
23391         break;
23392       default:
23393         jj_la1[319] = jj_gen;
23394         jj_consume_token(-1);
23395         throw new ParseException();
23396       }
23397       switch (jj_nt.kind) {
23398       case USING:
23399         jj_consume_token(USING);
23400         StringLiteral();
23401         break;
23402       default:
23403         jj_la1[320] = jj_gen;
23404         ;
23405       }
23406       switch (jj_nt.kind) {
23407       case 4:
23408         jj_consume_token(4);
23409         break;
23410       case 1:
23411         jj_consume_token(1);
23412         break;
23413       default:
23414         jj_la1[321] = jj_gen;
23415         jj_consume_token(-1);
23416         throw new ParseException();
23417       }
23418     jjtree.closeNodeScope(jjtn000, true);
23419     jjtc000 = false;
23420     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
23421     } catch (Throwable jjte000) {
23422     if (jjtc000) {
23423       jjtree.clearNodeScope(jjtn000);
23424       jjtc000 = false;
23425     } else {
23426       jjtree.popNode();
23427     }
23428     if (jjte000 instanceof RuntimeException) {
23429       {if (true) throw (RuntimeException)jjte000;}
23430     }
23431     if (jjte000 instanceof ParseException) {
23432       {if (true) throw (ParseException)jjte000;}
23433     }
23434     {if (true) throw (Error)jjte000;}
23435     } finally {
23436     if (jjtc000) {
23437       jjtree.closeNodeScope(jjtn000, true);
23438     }
23439     }
23440     throw new Error("Missing return statement in function");
23441   }
23442 
23443   final public ASTViewColumn ViewColumn() throws ParseException {
23444  /*@bgen(jjtree) ViewColumn */
23445   ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
23446   boolean jjtc000 = true;
23447   jjtree.openNodeScope(jjtn000);
23448     try {
23449       ID();
23450         jjtree.closeNodeScope(jjtn000, true);
23451         jjtc000 = false;
23452         {if (true) return jjtn000 ;}
23453     } catch (Throwable jjte000) {
23454     if (jjtc000) {
23455       jjtree.clearNodeScope(jjtn000);
23456       jjtc000 = false;
23457     } else {
23458       jjtree.popNode();
23459     }
23460     if (jjte000 instanceof RuntimeException) {
23461       {if (true) throw (RuntimeException)jjte000;}
23462     }
23463     if (jjte000 instanceof ParseException) {
23464       {if (true) throw (ParseException)jjte000;}
23465     }
23466     {if (true) throw (Error)jjte000;}
23467     } finally {
23468     if (jjtc000) {
23469       jjtree.closeNodeScope(jjtn000, true);
23470     }
23471     }
23472     throw new Error("Missing return statement in function");
23473   }
23474 
23475   final public ASTComment Comment() throws ParseException {
23476  /*@bgen(jjtree) Comment */
23477   ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
23478   boolean jjtc000 = true;
23479   jjtree.openNodeScope(jjtn000);
23480     try {
23481       jj_consume_token(COMMENT);
23482       jj_consume_token(ON);
23483       switch (jj_nt.kind) {
23484       case INDEXTYPE:
23485       case OPERATOR:
23486       case TABLE:
23487         switch (jj_nt.kind) {
23488         case TABLE:
23489           jj_consume_token(TABLE);
23490           break;
23491         case OPERATOR:
23492           jj_consume_token(OPERATOR);
23493           break;
23494         case INDEXTYPE:
23495           jj_consume_token(INDEXTYPE);
23496           break;
23497         default:
23498           jj_la1[322] = jj_gen;
23499           jj_consume_token(-1);
23500           throw new ParseException();
23501         }
23502         if (jj_2_61(2)) {
23503           ID();
23504           jj_consume_token(3);
23505         } else {
23506           ;
23507         }
23508         ID();
23509         break;
23510       case COLUMN:
23511         jj_consume_token(COLUMN);
23512         if (jj_2_62(2147483647)) {
23513           ID();
23514           jj_consume_token(3);
23515         } else {
23516           ;
23517         }
23518         ID();
23519         jj_consume_token(3);
23520         ID();
23521         break;
23522       default:
23523         jj_la1[323] = jj_gen;
23524         jj_consume_token(-1);
23525         throw new ParseException();
23526       }
23527       jj_consume_token(IS);
23528       jj_consume_token(STRING_LITERAL);
23529       switch (jj_nt.kind) {
23530       case 4:
23531         jj_consume_token(4);
23532         break;
23533       default:
23534         jj_la1[324] = jj_gen;
23535         ;
23536       }
23537         jjtree.closeNodeScope(jjtn000, true);
23538         jjtc000 = false;
23539         {if (true) return jjtn000 ;}
23540     } catch (Throwable jjte000) {
23541     if (jjtc000) {
23542       jjtree.clearNodeScope(jjtn000);
23543       jjtc000 = false;
23544     } else {
23545       jjtree.popNode();
23546     }
23547     if (jjte000 instanceof RuntimeException) {
23548       {if (true) throw (RuntimeException)jjte000;}
23549     }
23550     if (jjte000 instanceof ParseException) {
23551       {if (true) throw (ParseException)jjte000;}
23552     }
23553     {if (true) throw (Error)jjte000;}
23554     } finally {
23555     if (jjtc000) {
23556       jjtree.closeNodeScope(jjtn000, true);
23557     }
23558     }
23559     throw new Error("Missing return statement in function");
23560   }
23561 
23562 // SRT * /
23563   final public ASTTypeMethod TypeMethod() throws ParseException {
23564  /*@bgen(jjtree) TypeMethod */
23565   ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
23566   boolean jjtc000 = true;
23567   jjtree.openNodeScope(jjtn000);
23568     try {
23569         getToken(1);
23570         //System.err.println("typeMethod: Result of getToken(1) is \"" + startToken.toString() + "\"" );
23571 
23572       label_73:
23573       while (true) {
23574         switch (jj_nt.kind) {
23575         case FINAL:
23576         case INSTANTIABLE:
23577         case NOT:
23578         case OVERRIDING:
23579           ;
23580           break;
23581         default:
23582           jj_la1[325] = jj_gen;
23583           break label_73;
23584         }
23585         switch (jj_nt.kind) {
23586         case NOT:
23587           jj_consume_token(NOT);
23588           break;
23589         default:
23590           jj_la1[326] = jj_gen;
23591           ;
23592         }
23593         switch (jj_nt.kind) {
23594         case OVERRIDING:
23595           jj_consume_token(OVERRIDING);
23596           break;
23597         case INSTANTIABLE:
23598           jj_consume_token(INSTANTIABLE);
23599           break;
23600         case FINAL:
23601           jj_consume_token(FINAL);
23602           break;
23603         default:
23604           jj_la1[327] = jj_gen;
23605           jj_consume_token(-1);
23606           throw new ParseException();
23607         }
23608       }
23609       switch (jj_nt.kind) {
23610       case MAP:
23611       case ORDER:
23612         switch (jj_nt.kind) {
23613         case MAP:
23614           jj_consume_token(MAP);
23615           break;
23616         case ORDER:
23617           jj_consume_token(ORDER);
23618           break;
23619         default:
23620           jj_la1[328] = jj_gen;
23621           jj_consume_token(-1);
23622           throw new ParseException();
23623         }
23624         break;
23625       default:
23626         jj_la1[329] = jj_gen;
23627         ;
23628       }
23629       switch (jj_nt.kind) {
23630       case CONSTRUCTOR:
23631         jj_consume_token(CONSTRUCTOR);
23632         break;
23633       case MEMBER:
23634         jj_consume_token(MEMBER);
23635         break;
23636       case STATIC:
23637         jj_consume_token(STATIC);
23638         break;
23639       default:
23640         jj_la1[330] = jj_gen;
23641         jj_consume_token(-1);
23642         throw new ParseException();
23643       }
23644       MethodDeclarator();
23645       switch (jj_nt.kind) {
23646       case DETERMINISTIC:
23647         jj_consume_token(DETERMINISTIC);
23648         break;
23649       default:
23650         jj_la1[331] = jj_gen;
23651         ;
23652       }
23653       switch (jj_nt.kind) {
23654       case PARALLEL_ENABLE:
23655         jj_consume_token(PARALLEL_ENABLE);
23656         break;
23657       default:
23658         jj_la1[332] = jj_gen;
23659         ;
23660       }
23661       switch (jj_nt.kind) {
23662       case PIPELINED:
23663         jj_consume_token(PIPELINED);
23664         break;
23665       default:
23666         jj_la1[333] = jj_gen;
23667         ;
23668       }
23669       switch (jj_nt.kind) {
23670       case RESULT_CACHE:
23671         jj_consume_token(RESULT_CACHE);
23672         break;
23673       default:
23674         jj_la1[334] = jj_gen;
23675         ;
23676       }
23677       switch (jj_nt.kind) {
23678       case AS:
23679       case IS:
23680         switch (jj_nt.kind) {
23681         case IS:
23682           jj_consume_token(IS);
23683           break;
23684         case AS:
23685           jj_consume_token(AS);
23686           break;
23687         default:
23688           jj_la1[335] = jj_gen;
23689           jj_consume_token(-1);
23690           throw new ParseException();
23691         }
23692         switch (jj_nt.kind) {
23693         case LANGUAGE:
23694         case EXTERNAL:
23695           CallSpecTail();
23696           switch (jj_nt.kind) {
23697           case 4:
23698             jj_consume_token(4);
23699             break;
23700           default:
23701             jj_la1[336] = jj_gen;
23702             ;
23703           }
23704           break;
23705         case REPLACE:
23706         case DEFINER:
23707         case CURRENT_USER:
23708         case SERIALLY_REUSABLE:
23709         case RESTRICT_REFERENCES:
23710         case EXCEPTION_INIT:
23711         case AUTONOMOUS_TRANSACTION:
23712         case INLINE:
23713         case ADD:
23714         case AGGREGATE:
23715         case ALL:
23716         case ALTER:
23717         case AND:
23718         case ANY:
23719         case ARRAY:
23720         case AS:
23721         case ASC:
23722         case AT:
23723         case ATTRIBUTE:
23724         case AUTHID:
23725         case AVG:
23726         case BEGIN:
23727         case BETWEEN:
23728         case BINARY_INTEGER:
23729         case BODY:
23730         case BOOLEAN:
23731         case BULK:
23732         case BY:
23733         case BYTE:
23734         case CASCADE:
23735         case CASE:
23736         case CHAR:
23737         case CHAR_BASE:
23738         case CHECK:
23739         case CLOSE:
23740         case CLUSTER:
23741         case COALESCE:
23742         case COLLECT:
23743         case COLUMN:
23744         case COMMENT:
23745         case COMMIT:
23746         case COMPRESS:
23747         case CONNECT:
23748         case CONSTANT:
23749         case CONSTRUCTOR:
23750         case CONTINUE:
23751         case CONVERT:
23752         case CREATE:
23753         case CURRENT:
23754         case CURRVAL:
23755         case CURSOR:
23756         case DATA:
23757         case DATE:
23758         case DAY:
23759         case DECLARE:
23760         case DECIMAL:
23761         case _DEFAULT:
23762         case DELETE:
23763         case DESC:
23764         case DISABLE:
23765         case DISTINCT:
23766         case DO:
23767         case DROP:
23768         case EDITIONABLE:
23769         case ELEMENT:
23770         case ELSE:
23771         case ELSIF:
23772         case ENABLE:
23773         case ESCAPE:
23774         case EXCEPT:
23775         case EXCEPTION:
23776         case EXCEPTIONS:
23777         case EXCLUSIVE:
23778         case EXECUTE:
23779         case EXISTS:
23780         case EXIT:
23781         case EXTENDS:
23782         case EXTRACT:
23783         case FALSE:
23784         case FETCH:
23785         case FINAL:
23786         case FLOAT:
23787         case FOR:
23788         case FORALL:
23789         case FORCE:
23790         case FROM:
23791         case FUNCTION:
23792         case GLOBAL:
23793         case GOTO:
23794         case GROUP:
23795         case HASH:
23796         case HAVING:
23797         case HEAP:
23798         case HOUR:
23799         case IF:
23800         case IMMEDIATE:
23801         case IN:
23802         case INDEX:
23803         case INDICES:
23804         case INDEXTYPE:
23805         case INDICATOR:
23806         case INSERT:
23807         case INSTANTIABLE:
23808         case INTEGER:
23809         case INTERFACE:
23810         case INTERSECT:
23811         case INTERVAL:
23812         case INTO:
23813         case INVALIDATE:
23814         case IS:
23815         case ISOLATION:
23816         case JAVA:
23817         case LEVEL:
23818         case LIKE:
23819         case LIMIT:
23820         case LIMITED:
23821         case LOCK:
23822         case LONG:
23823         case LOOP:
23824         case MAP:
23825         case MAX:
23826         case MEMBER:
23827         case MERGE:
23828         case MIN:
23829         case MINUS:
23830         case MINUTE:
23831         case MLSLABEL:
23832         case MODIFY:
23833         case MOD:
23834         case MODE:
23835         case MONTH:
23836         case NATURAL:
23837         case NATURALN:
23838         case NEW:
23839         case NEXTVAL:
23840         case NO:
23841         case NOCOPY:
23842         case NONEDITIONABLE:
23843         case NOT:
23844         case NOWAIT:
23845         case NULL:
23846         case NULLIF:
23847         case NUMBER:
23848         case BFILE_BASE:
23849         case BLOB_BASE:
23850         case CLOB_BASE:
23851         case DATE_BASE:
23852         case NUMBER_BASE:
23853         case OBJECT:
23854         case OCIROWID:
23855         case OF:
23856         case OID:
23857         case ON:
23858         case OPAQUE:
23859         case OPEN:
23860         case OPERATOR:
23861         case OPTION:
23862         case OR:
23863         case ORDER:
23864         case ORGANIZATION:
23865         case OTHERS:
23866         case OUT:
23867         case OVERRIDING:
23868         case PACKAGE:
23869         case PARTITION:
23870         case PCTFREE:
23871         case PLS_INTEGER:
23872         case POSITIVE:
23873         case POSITIVEN:
23874         case PRAGMA:
23875         case PRESERVE:
23876         case PRIOR:
23877         case PROMPT:
23878         case PRIVATE:
23879         case PROCEDURE:
23880         case PUBLIC:
23881         case RAISE:
23882         case RANGE:
23883         case RAW:
23884         case REAL:
23885         case RECORD:
23886         case REF:
23887         case RELEASE:
23888         case RELIES_ON:
23889         case RENAME:
23890         case RESULT:
23891         case RETURN:
23892         case RETURNING:
23893         case REVERSE:
23894         case ROLLBACK:
23895         case ROW:
23896         case ROWS:
23897         case ROWID:
23898         case ROWNUM:
23899         case ROWTYPE:
23900         case SAVE:
23901         case SAVEPOINT:
23902         case SECOND:
23903         case SELECT:
23904         case SELF:
23905         case SEPARATE:
23906         case SET:
23907         case SHARE:
23908         case SMALLINT:
23909         case SPACE:
23910         case SQL:
23911         case SQLCODE:
23912         case SQLERRM:
23913         case START:
23914         case STATIC:
23915         case STDDEV:
23916         case SUBTYPE:
23917         case SUBSTITUTABLE:
23918         case SUCCESSFUL:
23919         case SUM:
23920         case SYNONYM:
23921         case SYSDATE:
23922         case SYS_REFCURSOR:
23923         case TABLE:
23924         case TEMPORARY:
23925         case THEN:
23926         case TIME:
23927         case TIMESTAMP:
23928         case TIMEZONE_REGION:
23929         case TIMEZONE_ABBR:
23930         case TIMEZONE_MINUTE:
23931         case TIMEZONE_HOUR:
23932         case TO:
23933         case TRANSACTION:
23934         case TRIGGER:
23935         case TRUE:
23936         case TYPE:
23937         case UI:
23938         case UNDER:
23939         case USING:
23940         case WHILE:
23941         case YES:
23942         case SHOW:
23943         case A:
23944         case UPDATE:
23945         case VARCHAR:
23946         case VARCHAR2:
23947         case DOUBLE:
23948         case DEC:
23949         case PRECISION:
23950         case INT:
23951         case NUMERIC:
23952         case SIGNTYPE:
23953         case NCHAR:
23954         case NVARCHAR2:
23955         case STRING:
23956         case UROWID:
23957         case VARRAY:
23958         case VARYING:
23959         case BFILE:
23960         case BLOB:
23961         case CLOB:
23962         case NCLOB:
23963         case YEAR:
23964         case LOCAL:
23965         case WITH:
23966         case ZONE:
23967         case CHARACTER:
23968         case AFTER:
23969         case BEFORE:
23970         case OLD:
23971         case PARENT:
23972         case CC_IF:
23973         case ANALYZE:
23974         case ASSOCIATE:
23975         case AUDIT:
23976         case COMPOUND:
23977         case DATABASE:
23978         case CALL:
23979         case DDL:
23980         case DISASSOCIATE:
23981         case EACH:
23982         case FOLLOWS:
23983         case LOGOFF:
23984         case LOGON:
23985         case NESTED:
23986         case NOAUDIT:
23987         case SCHEMA:
23988         case SERVERERROR:
23989         case SHUTDOWN:
23990         case STARTUP:
23991         case STATEMENT:
23992         case STATISTICS:
23993         case SUSPEND:
23994         case TRUNCATE:
23995         case WRAPPED:
23996         case LIBRARY:
23997         case NAME:
23998         case STRUCT:
23999         case CONTEXT:
24000         case PARAMETERS:
24001         case LENGTH:
24002         case TDO:
24003         case MAXLEN:
24004         case CHARSETID:
24005         case CHARSETFORM:
24006         case ACCEPT:
24007         case ACCESSIBLE:
24008         case COPY:
24009         case DEFINE:
24010         case DISCONNECT:
24011         case HOST:
24012         case PRINT:
24013         case QUIT:
24014         case REMARK:
24015         case UNDEFINE:
24016         case VARIABLE:
24017         case WHENEVER:
24018         case ATTACH:
24019         case CAST:
24020         case TREAT:
24021         case TRIM:
24022         case LEFT:
24023         case RIGHT:
24024         case BOTH:
24025         case EMPTY:
24026         case MULTISET:
24027         case SUBMULTISET:
24028         case LEADING:
24029         case TRAILING:
24030         case CHAR_CS:
24031         case NCHAR_CS:
24032         case DBTIMEZONE:
24033         case SESSIONTIMEZONE:
24034         case AUTHENTICATED:
24035         case LINK:
24036         case SHARED:
24037         case DIRECTORY:
24038         case USER:
24039         case IDENTIFIER:
24040         case QUOTED_LITERAL:
24041         case SQLDATA_CLASS:
24042         case CUSTOMDATUM_CLASS:
24043         case ORADATA_CLASS:
24044         case JAVA_INTERFACE_CLASS:
24045           DeclarativeSection();
24046           jj_consume_token(BEGIN);
24047           label_74:
24048           while (true) {
24049             switch (jj_nt.kind) {
24050             case 5:
24051             case 16:
24052             case 17:
24053             case 21:
24054             case REPLACE:
24055             case DEFINER:
24056             case CURRENT_USER:
24057             case LANGUAGE:
24058             case INLINE:
24059             case ADD:
24060             case AGGREGATE:
24061             case ARRAY:
24062             case AT:
24063             case ATTRIBUTE:
24064             case AUTHID:
24065             case BEGIN:
24066             case BODY:
24067             case BULK:
24068             case BYTE:
24069             case CASCADE:
24070             case CASE:
24071             case CLOSE:
24072             case COALESCE:
24073             case COLLECT:
24074             case COLUMN:
24075             case COMMENT:
24076             case COMMIT:
24077             case CONSTRUCTOR:
24078             case CONTINUE:
24079             case CONVERT:
24080             case CURRENT:
24081             case CURSOR:
24082             case DATA:
24083             case DATE:
24084             case DAY:
24085             case DECLARE:
24086             case DELETE:
24087             case DISABLE:
24088             case EDITIONABLE:
24089             case ELEMENT:
24090             case ENABLE:
24091             case ESCAPE:
24092             case EXCEPT:
24093             case EXCEPTIONS:
24094             case EXECUTE:
24095             case EXIT:
24096             case EXTERNAL:
24097             case EXTENDS:
24098             case EXTRACT:
24099             case FALSE:
24100             case FETCH:
24101             case FINAL:
24102             case FOR:
24103             case FORALL:
24104             case FORCE:
24105             case FUNCTION:
24106             case GLOBAL:
24107             case GOTO:
24108             case HASH:
24109             case HEAP:
24110             case HOUR:
24111             case IF:
24112             case IMMEDIATE:
24113             case INDICES:
24114             case INDEXTYPE:
24115             case INDICATOR:
24116             case INSERT:
24117             case INSTANTIABLE:
24118             case INTERVAL:
24119             case INVALIDATE:
24120             case ISOLATION:
24121             case JAVA:
24122             case LEVEL:
24123             case LIMIT:
24124             case LOCK:
24125             case LOOP:
24126             case MAP:
24127             case MAX:
24128             case MEMBER:
24129             case MERGE:
24130             case MIN:
24131             case MINUTE:
24132             case MLSLABEL:
24133             case MODIFY:
24134             case MOD:
24135             case MONTH:
24136             case NATURAL:
24137             case NEW:
24138             case NEW_DOT:
24139             case NO:
24140             case NONEDITIONABLE:
24141             case NOT:
24142             case NULL:
24143             case NULLIF:
24144             case OBJECT:
24145             case OID:
24146             case OPAQUE:
24147             case OPEN:
24148             case OPERATOR:
24149             case ORGANIZATION:
24150             case OTHERS:
24151             case OVERRIDING:
24152             case PACKAGE:
24153             case PARTITION:
24154             case PIPE:
24155             case PRAGMA:
24156             case PRESERVE:
24157             case PRIVATE:
24158             case PROCEDURE:
24159             case RAISE:
24160             case RANGE:
24161             case RAW:
24162             case REAL:
24163             case RECORD:
24164             case REF:
24165             case RELEASE:
24166             case RELIES_ON:
24167             case RENAME:
24168             case RESULT:
24169             case RETURN:
24170             case RETURNING:
24171             case REVERSE:
24172             case ROLLBACK:
24173             case ROW:
24174             case ROWS:
24175             case ROWID:
24176             case ROWNUM:
24177             case SAVE:
24178             case SAVEPOINT:
24179             case SECOND:
24180             case SELECT:
24181             case SELF:
24182             case SET:
24183             case SPACE:
24184             case SQL:
24185             case SQLCODE:
24186             case SQLERRM:
24187             case STATIC:
24188             case SUBTYPE:
24189             case SUBSTITUTABLE:
24190             case SUCCESSFUL:
24191             case SYSDATE:
24192             case SYS_REFCURSOR:
24193             case TEMPORARY:
24194             case TIME:
24195             case TIMESTAMP:
24196             case TIMEZONE_REGION:
24197             case TIMEZONE_ABBR:
24198             case TIMEZONE_MINUTE:
24199             case TIMEZONE_HOUR:
24200             case TRANSACTION:
24201             case TRUE:
24202             case TYPE:
24203             case UNDER:
24204             case USING:
24205             case WHILE:
24206             case YES:
24207             case SHOW:
24208             case A:
24209             case UPDATE:
24210             case DOUBLE:
24211             case DEC:
24212             case PRECISION:
24213             case INT:
24214             case NUMERIC:
24215             case NCHAR:
24216             case NVARCHAR2:
24217             case STRING:
24218             case UROWID:
24219             case VARRAY:
24220             case VARYING:
24221             case BFILE:
24222             case BLOB:
24223             case CLOB:
24224             case NCLOB:
24225             case YEAR:
24226             case LOCAL:
24227             case WITH:
24228             case ZONE:
24229             case CHARACTER:
24230             case AFTER:
24231             case BEFORE:
24232             case OLD:
24233             case PARENT:
24234             case CC_IF:
24235             case CC_ERROR:
24236             case ANALYZE:
24237             case ASSOCIATE:
24238             case AUDIT:
24239             case COMPOUND:
24240             case DATABASE:
24241             case CALL:
24242             case DDL:
24243             case DISASSOCIATE:
24244             case EACH:
24245             case FOLLOWS:
24246             case LOGOFF:
24247             case LOGON:
24248             case NESTED:
24249             case NOAUDIT:
24250             case SCHEMA:
24251             case SERVERERROR:
24252             case SHUTDOWN:
24253             case STARTUP:
24254             case STATEMENT:
24255             case STATISTICS:
24256             case SUSPEND:
24257             case TRUNCATE:
24258             case WRAPPED:
24259             case LIBRARY:
24260             case NAME:
24261             case STRUCT:
24262             case CONTEXT:
24263             case PARAMETERS:
24264             case LENGTH:
24265             case TDO:
24266             case MAXLEN:
24267             case CHARSETID:
24268             case CHARSETFORM:
24269             case ACCEPT:
24270             case ACCESSIBLE:
24271             case COPY:
24272             case DEFINE:
24273             case DISCONNECT:
24274             case HOST:
24275             case PRINT:
24276             case QUIT:
24277             case REMARK:
24278             case UNDEFINE:
24279             case VARIABLE:
24280             case WHENEVER:
24281             case ATTACH:
24282             case CAST:
24283             case TREAT:
24284             case TRIM:
24285             case LEFT:
24286             case RIGHT:
24287             case BOTH:
24288             case EMPTY:
24289             case MULTISET:
24290             case SUBMULTISET:
24291             case LEADING:
24292             case TRAILING:
24293             case CHAR_CS:
24294             case NCHAR_CS:
24295             case DBTIMEZONE:
24296             case SESSIONTIMEZONE:
24297             case AUTHENTICATED:
24298             case LINK:
24299             case SHARED:
24300             case DIRECTORY:
24301             case USER:
24302             case IDENTIFIER:
24303             case UNSIGNED_NUMERIC_LITERAL:
24304             case CHARACTER_LITERAL:
24305             case STRING_LITERAL:
24306             case QUOTED_LITERAL:
24307               ;
24308               break;
24309             default:
24310               jj_la1[337] = jj_gen;
24311               break label_74;
24312             }
24313             Statement();
24314           }
24315           switch (jj_nt.kind) {
24316           case EXCEPTION:
24317             ExceptionHandler();
24318             break;
24319           default:
24320             jj_la1[338] = jj_gen;
24321             ;
24322           }
24323           jj_consume_token(END);
24324           switch (jj_nt.kind) {
24325           case REPLACE:
24326           case DEFINER:
24327           case CURRENT_USER:
24328           case SERIALLY_REUSABLE:
24329           case RESTRICT_REFERENCES:
24330           case EXCEPTION_INIT:
24331           case AUTONOMOUS_TRANSACTION:
24332           case LANGUAGE:
24333           case INLINE:
24334           case ADD:
24335           case AGGREGATE:
24336           case ALL:
24337           case ALTER:
24338           case AND:
24339           case ANY:
24340           case ARRAY:
24341           case AS:
24342           case ASC:
24343           case AT:
24344           case ATTRIBUTE:
24345           case AUTHID:
24346           case AVG:
24347           case BETWEEN:
24348           case BINARY_INTEGER:
24349           case BODY:
24350           case BOOLEAN:
24351           case BULK:
24352           case BY:
24353           case BYTE:
24354           case CASCADE:
24355           case CASE:
24356           case CHAR:
24357           case CHAR_BASE:
24358           case CHECK:
24359           case CLOSE:
24360           case CLUSTER:
24361           case COALESCE:
24362           case COLLECT:
24363           case COLUMN:
24364           case COMMENT:
24365           case COMMIT:
24366           case COMPRESS:
24367           case CONNECT:
24368           case CONSTANT:
24369           case CONSTRUCTOR:
24370           case CONTINUE:
24371           case CONVERT:
24372           case CREATE:
24373           case CURRENT:
24374           case CURRVAL:
24375           case CURSOR:
24376           case DATA:
24377           case DATE:
24378           case DAY:
24379           case DECLARE:
24380           case DECIMAL:
24381           case _DEFAULT:
24382           case DELETE:
24383           case DESC:
24384           case DISABLE:
24385           case DISTINCT:
24386           case DO:
24387           case DROP:
24388           case EDITIONABLE:
24389           case ELEMENT:
24390           case ELSE:
24391           case ELSIF:
24392           case ENABLE:
24393           case ESCAPE:
24394           case EXCEPT:
24395           case EXCEPTION:
24396           case EXCEPTIONS:
24397           case EXCLUSIVE:
24398           case EXECUTE:
24399           case EXISTS:
24400           case EXIT:
24401           case EXTERNAL:
24402           case EXTENDS:
24403           case EXTRACT:
24404           case FALSE:
24405           case FETCH:
24406           case FINAL:
24407           case FLOAT:
24408           case FOR:
24409           case FORALL:
24410           case FORCE:
24411           case FROM:
24412           case FUNCTION:
24413           case GLOBAL:
24414           case GOTO:
24415           case GROUP:
24416           case HASH:
24417           case HAVING:
24418           case HEAP:
24419           case HOUR:
24420           case IF:
24421           case IMMEDIATE:
24422           case IN:
24423           case INDEX:
24424           case INDICES:
24425           case INDEXTYPE:
24426           case INDICATOR:
24427           case INSERT:
24428           case INSTANTIABLE:
24429           case INTEGER:
24430           case INTERFACE:
24431           case INTERSECT:
24432           case INTERVAL:
24433           case INTO:
24434           case INVALIDATE:
24435           case IS:
24436           case ISOLATION:
24437           case JAVA:
24438           case LEVEL:
24439           case LIKE:
24440           case LIMIT:
24441           case LIMITED:
24442           case LOCK:
24443           case LONG:
24444           case LOOP:
24445           case MAP:
24446           case MAX:
24447           case MEMBER:
24448           case MERGE:
24449           case MIN:
24450           case MINUS:
24451           case MINUTE:
24452           case MLSLABEL:
24453           case MODIFY:
24454           case MOD:
24455           case MODE:
24456           case MONTH:
24457           case NATURAL:
24458           case NATURALN:
24459           case NEW:
24460           case NEXTVAL:
24461           case NO:
24462           case NOCOPY:
24463           case NONEDITIONABLE:
24464           case NOT:
24465           case NOWAIT:
24466           case NULL:
24467           case NULLIF:
24468           case NUMBER:
24469           case BFILE_BASE:
24470           case BLOB_BASE:
24471           case CLOB_BASE:
24472           case DATE_BASE:
24473           case NUMBER_BASE:
24474           case OBJECT:
24475           case OCIROWID:
24476           case OF:
24477           case OID:
24478           case ON:
24479           case OPAQUE:
24480           case OPEN:
24481           case OPERATOR:
24482           case OPTION:
24483           case OR:
24484           case ORDER:
24485           case ORGANIZATION:
24486           case OTHERS:
24487           case OUT:
24488           case OVERRIDING:
24489           case PACKAGE:
24490           case PARTITION:
24491           case PCTFREE:
24492           case PLS_INTEGER:
24493           case POSITIVE:
24494           case POSITIVEN:
24495           case PRESERVE:
24496           case PRIOR:
24497           case PROMPT:
24498           case PRIVATE:
24499           case PROCEDURE:
24500           case PUBLIC:
24501           case RAISE:
24502           case RANGE:
24503           case RAW:
24504           case REAL:
24505           case RECORD:
24506           case REF:
24507           case RELEASE:
24508           case RELIES_ON:
24509           case RENAME:
24510           case RESULT:
24511           case RETURN:
24512           case RETURNING:
24513           case REVERSE:
24514           case ROLLBACK:
24515           case ROW:
24516           case ROWS:
24517           case ROWID:
24518           case ROWNUM:
24519           case ROWTYPE:
24520           case SAVE:
24521           case SAVEPOINT:
24522           case SECOND:
24523           case SELECT:
24524           case SELF:
24525           case SEPARATE:
24526           case SET:
24527           case SHARE:
24528           case SMALLINT:
24529           case SPACE:
24530           case SQL:
24531           case SQLCODE:
24532           case SQLERRM:
24533           case START:
24534           case STATIC:
24535           case STDDEV:
24536           case SUBTYPE:
24537           case SUBSTITUTABLE:
24538           case SUCCESSFUL:
24539           case SUM:
24540           case SYNONYM:
24541           case SYSDATE:
24542           case SYS_REFCURSOR:
24543           case TABLE:
24544           case TEMPORARY:
24545           case THEN:
24546           case TIME:
24547           case TIMESTAMP:
24548           case TIMEZONE_REGION:
24549           case TIMEZONE_ABBR:
24550           case TIMEZONE_MINUTE:
24551           case TIMEZONE_HOUR:
24552           case TO:
24553           case TRANSACTION:
24554           case TRIGGER:
24555           case TRUE:
24556           case TYPE:
24557           case UI:
24558           case UNDER:
24559           case USING:
24560           case WHILE:
24561           case YES:
24562           case SHOW:
24563           case A:
24564           case UPDATE:
24565           case VARCHAR:
24566           case VARCHAR2:
24567           case DOUBLE:
24568           case DEC:
24569           case PRECISION:
24570           case INT:
24571           case NUMERIC:
24572           case SIGNTYPE:
24573           case NCHAR:
24574           case NVARCHAR2:
24575           case STRING:
24576           case UROWID:
24577           case VARRAY:
24578           case VARYING:
24579           case BFILE:
24580           case BLOB:
24581           case CLOB:
24582           case NCLOB:
24583           case YEAR:
24584           case LOCAL:
24585           case WITH:
24586           case ZONE:
24587           case CHARACTER:
24588           case AFTER:
24589           case BEFORE:
24590           case OLD:
24591           case PARENT:
24592           case ANALYZE:
24593           case ASSOCIATE:
24594           case AUDIT:
24595           case COMPOUND:
24596           case DATABASE:
24597           case CALL:
24598           case DDL:
24599           case DISASSOCIATE:
24600           case EACH:
24601           case FOLLOWS:
24602           case LOGOFF:
24603           case LOGON:
24604           case NESTED:
24605           case NOAUDIT:
24606           case SCHEMA:
24607           case SERVERERROR:
24608           case SHUTDOWN:
24609           case STARTUP:
24610           case STATEMENT:
24611           case STATISTICS:
24612           case SUSPEND:
24613           case TRUNCATE:
24614           case WRAPPED:
24615           case LIBRARY:
24616           case NAME:
24617           case STRUCT:
24618           case CONTEXT:
24619           case PARAMETERS:
24620           case LENGTH:
24621           case TDO:
24622           case MAXLEN:
24623           case CHARSETID:
24624           case CHARSETFORM:
24625           case ACCEPT:
24626           case ACCESSIBLE:
24627           case COPY:
24628           case DEFINE:
24629           case DISCONNECT:
24630           case HOST:
24631           case PRINT:
24632           case QUIT:
24633           case REMARK:
24634           case UNDEFINE:
24635           case VARIABLE:
24636           case WHENEVER:
24637           case ATTACH:
24638           case CAST:
24639           case TREAT:
24640           case TRIM:
24641           case LEFT:
24642           case RIGHT:
24643           case BOTH:
24644           case EMPTY:
24645           case MULTISET:
24646           case SUBMULTISET:
24647           case LEADING:
24648           case TRAILING:
24649           case CHAR_CS:
24650           case NCHAR_CS:
24651           case DBTIMEZONE:
24652           case SESSIONTIMEZONE:
24653           case AUTHENTICATED:
24654           case LINK:
24655           case SHARED:
24656           case DIRECTORY:
24657           case USER:
24658           case IDENTIFIER:
24659           case QUOTED_LITERAL:
24660           case SQLDATA_CLASS:
24661           case CUSTOMDATUM_CLASS:
24662           case ORADATA_CLASS:
24663           case JAVA_INTERFACE_CLASS:
24664             ID();
24665             break;
24666           default:
24667             jj_la1[339] = jj_gen;
24668             ;
24669           }
24670           jj_consume_token(4);
24671           break;
24672         default:
24673           jj_la1[340] = jj_gen;
24674           jj_consume_token(-1);
24675           throw new ParseException();
24676         }
24677         break;
24678       default:
24679         jj_la1[341] = jj_gen;
24680         ;
24681       }
24682         jjtree.closeNodeScope(jjtn000, true);
24683         jjtc000 = false;
24684         {if (true) return jjtn000 ;}
24685     } catch (Throwable jjte000) {
24686           if (jjtc000) {
24687             jjtree.clearNodeScope(jjtn000);
24688             jjtc000 = false;
24689           } else {
24690             jjtree.popNode();
24691           }
24692           if (jjte000 instanceof RuntimeException) {
24693             {if (true) throw (RuntimeException)jjte000;}
24694           }
24695           if (jjte000 instanceof ParseException) {
24696             {if (true) throw (ParseException)jjte000;}
24697           }
24698           {if (true) throw (Error)jjte000;}
24699     } finally {
24700           if (jjtc000) {
24701             jjtree.closeNodeScope(jjtn000, true);
24702           }
24703     }
24704     throw new Error("Missing return statement in function");
24705   }
24706 
24707   final public ASTTypeSpecification TypeSpecification() throws ParseException {
24708  /*@bgen(jjtree) TypeSpecification */
24709  ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
24710  boolean jjtc000 = true;
24711  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24712     try {
24713       switch (jj_nt.kind) {
24714       case CREATE:
24715         jj_consume_token(CREATE);
24716         switch (jj_nt.kind) {
24717         case OR:
24718           jj_consume_token(OR);
24719           jj_consume_token(REPLACE);
24720           break;
24721         default:
24722           jj_la1[342] = jj_gen;
24723           ;
24724         }
24725         switch (jj_nt.kind) {
24726         case EDITIONABLE:
24727         case NONEDITIONABLE:
24728           switch (jj_nt.kind) {
24729           case EDITIONABLE:
24730             jj_consume_token(EDITIONABLE);
24731             break;
24732           case NONEDITIONABLE:
24733             jj_consume_token(NONEDITIONABLE);
24734             break;
24735           default:
24736             jj_la1[343] = jj_gen;
24737             jj_consume_token(-1);
24738             throw new ParseException();
24739           }
24740           break;
24741         default:
24742           jj_la1[344] = jj_gen;
24743           ;
24744         }
24745         break;
24746       default:
24747         jj_la1[345] = jj_gen;
24748         ;
24749       }
24750       jj_consume_token(TYPE);
24751       simpleNode = ObjectNameDeclaration();
24752       switch (jj_nt.kind) {
24753       case FORCE:
24754         jj_consume_token(FORCE);
24755         break;
24756       default:
24757         jj_la1[346] = jj_gen;
24758         ;
24759       }
24760       if (jj_2_63(2)) {
24761         jj_consume_token(OID);
24762         jj_consume_token(STRING_LITERAL);
24763       } else {
24764         ;
24765       }
24766       label_75:
24767       while (true) {
24768         if (jj_2_64(2)) {
24769           ;
24770         } else {
24771           break label_75;
24772         }
24773         switch (jj_nt.kind) {
24774         case AUTHID:
24775           jj_consume_token(AUTHID);
24776           switch (jj_nt.kind) {
24777           case CURRENT_USER:
24778             jj_consume_token(CURRENT_USER);
24779             break;
24780           case DEFINER:
24781             jj_consume_token(DEFINER);
24782             break;
24783           default:
24784             jj_la1[347] = jj_gen;
24785             jj_consume_token(-1);
24786             throw new ParseException();
24787           }
24788           break;
24789         case ACCESSIBLE:
24790           AccessibleByClause();
24791           break;
24792         default:
24793           jj_la1[348] = jj_gen;
24794           jj_consume_token(-1);
24795           throw new ParseException();
24796         }
24797       }
24798       switch (jj_nt.kind) {
24799       case AS:
24800       case IS:
24801       case UNDER:
24802         switch (jj_nt.kind) {
24803         case UNDER:
24804           jj_consume_token(UNDER);
24805           ObjectNameDeclaration();
24806           break;
24807         default:
24808           jj_la1[355] = jj_gen;
24809           if (jj_2_65(2)) {
24810             switch (jj_nt.kind) {
24811             case IS:
24812               jj_consume_token(IS);
24813               break;
24814             case AS:
24815               jj_consume_token(AS);
24816               break;
24817             default:
24818               jj_la1[349] = jj_gen;
24819               jj_consume_token(-1);
24820               throw new ParseException();
24821             }
24822             jj_consume_token(OBJECT);
24823           } else if (jj_2_66(2)) {
24824             switch (jj_nt.kind) {
24825             case IS:
24826               jj_consume_token(IS);
24827               break;
24828             case AS:
24829               jj_consume_token(AS);
24830               break;
24831             default:
24832               jj_la1[350] = jj_gen;
24833               jj_consume_token(-1);
24834               throw new ParseException();
24835             }
24836             jj_consume_token(OPAQUE);
24837             jj_consume_token(VARYING);
24838             jj_consume_token(24);
24839             jj_consume_token(USING);
24840             jj_consume_token(LIBRARY);
24841             switch (jj_nt.kind) {
24842             case IDENTIFIER:
24843               jj_consume_token(IDENTIFIER);
24844               break;
24845             case QUOTED_LITERAL:
24846               jj_consume_token(QUOTED_LITERAL);
24847               break;
24848             case STRING_LITERAL:
24849               StringLiteral();
24850               break;
24851             default:
24852               jj_la1[351] = jj_gen;
24853               jj_consume_token(-1);
24854               throw new ParseException();
24855             }
24856             switch (jj_nt.kind) {
24857             case 3:
24858               jj_consume_token(3);
24859               switch (jj_nt.kind) {
24860               case IDENTIFIER:
24861                 jj_consume_token(IDENTIFIER);
24862                 break;
24863               case QUOTED_LITERAL:
24864                 jj_consume_token(QUOTED_LITERAL);
24865                 break;
24866               case STRING_LITERAL:
24867                 StringLiteral();
24868                 break;
24869               default:
24870                 jj_la1[352] = jj_gen;
24871                 jj_consume_token(-1);
24872                 throw new ParseException();
24873               }
24874               break;
24875             default:
24876               jj_la1[353] = jj_gen;
24877               ;
24878             }
24879           } else if (jj_2_67(2)) {
24880             switch (jj_nt.kind) {
24881             case IS:
24882               jj_consume_token(IS);
24883               break;
24884             case AS:
24885               jj_consume_token(AS);
24886               break;
24887             default:
24888               jj_la1[354] = jj_gen;
24889               jj_consume_token(-1);
24890               throw new ParseException();
24891             }
24892             CollectionTypeName();
24893             jj_consume_token(OF);
24894             Datatype();
24895           } else {
24896             jj_consume_token(-1);
24897             throw new ParseException();
24898           }
24899         }
24900         break;
24901       default:
24902         jj_la1[356] = jj_gen;
24903         ;
24904       }
24905       if (jj_2_68(8)) {
24906         jj_consume_token(EXTERNAL);
24907         jj_consume_token(IDENTIFIER);
24908         jj_consume_token(IDENTIFIER);
24909         jj_consume_token(LANGUAGE);
24910         jj_consume_token(JAVA);
24911         jj_consume_token(USING);
24912         jj_consume_token(IDENTIFIER);
24913       } else {
24914         ;
24915       }
24916       switch (jj_nt.kind) {
24917       case WRAPPED:
24918         WrappedObject();
24919         break;
24920       default:
24921         jj_la1[357] = jj_gen;
24922         ;
24923       }
24924       switch (jj_nt.kind) {
24925       case 5:
24926         jj_consume_token(5);
24927         label_76:
24928         while (true) {
24929           switch (jj_nt.kind) {
24930           case REPLACE:
24931           case DEFINER:
24932           case CURRENT_USER:
24933           case SERIALLY_REUSABLE:
24934           case RESTRICT_REFERENCES:
24935           case EXCEPTION_INIT:
24936           case AUTONOMOUS_TRANSACTION:
24937           case LANGUAGE:
24938           case INLINE:
24939           case ADD:
24940           case AGGREGATE:
24941           case ALL:
24942           case ALTER:
24943           case AND:
24944           case ANY:
24945           case ARRAY:
24946           case AS:
24947           case ASC:
24948           case AT:
24949           case ATTRIBUTE:
24950           case AUTHID:
24951           case AVG:
24952           case BETWEEN:
24953           case BINARY_INTEGER:
24954           case BODY:
24955           case BOOLEAN:
24956           case BULK:
24957           case BY:
24958           case BYTE:
24959           case CASCADE:
24960           case CASE:
24961           case CHAR:
24962           case CHAR_BASE:
24963           case CHECK:
24964           case CLOSE:
24965           case CLUSTER:
24966           case COALESCE:
24967           case COLLECT:
24968           case COLUMN:
24969           case COMMENT:
24970           case COMMIT:
24971           case COMPRESS:
24972           case CONNECT:
24973           case CONSTANT:
24974           case CONSTRUCTOR:
24975           case CONTINUE:
24976           case CONVERT:
24977           case CREATE:
24978           case CURRENT:
24979           case CURRVAL:
24980           case CURSOR:
24981           case DATA:
24982           case DATE:
24983           case DAY:
24984           case DECLARE:
24985           case DECIMAL:
24986           case _DEFAULT:
24987           case DELETE:
24988           case DESC:
24989           case DISABLE:
24990           case DISTINCT:
24991           case DO:
24992           case DROP:
24993           case EDITIONABLE:
24994           case ELEMENT:
24995           case ELSE:
24996           case ELSIF:
24997           case ENABLE:
24998           case ESCAPE:
24999           case EXCEPT:
25000           case EXCEPTION:
25001           case EXCEPTIONS:
25002           case EXCLUSIVE:
25003           case EXECUTE:
25004           case EXISTS:
25005           case EXIT:
25006           case EXTERNAL:
25007           case EXTENDS:
25008           case EXTRACT:
25009           case FALSE:
25010           case FETCH:
25011           case FINAL:
25012           case FLOAT:
25013           case FOR:
25014           case FORALL:
25015           case FORCE:
25016           case FROM:
25017           case FUNCTION:
25018           case GLOBAL:
25019           case GOTO:
25020           case GROUP:
25021           case HASH:
25022           case HAVING:
25023           case HEAP:
25024           case HOUR:
25025           case IF:
25026           case IMMEDIATE:
25027           case IN:
25028           case INDEX:
25029           case INDICES:
25030           case INDEXTYPE:
25031           case INDICATOR:
25032           case INSERT:
25033           case INSTANTIABLE:
25034           case INTEGER:
25035           case INTERFACE:
25036           case INTERSECT:
25037           case INTERVAL:
25038           case INTO:
25039           case INVALIDATE:
25040           case IS:
25041           case ISOLATION:
25042           case JAVA:
25043           case LEVEL:
25044           case LIKE:
25045           case LIMIT:
25046           case LIMITED:
25047           case LOCK:
25048           case LONG:
25049           case LOOP:
25050           case MAP:
25051           case MAX:
25052           case MEMBER:
25053           case MERGE:
25054           case MIN:
25055           case MINUS:
25056           case MINUTE:
25057           case MLSLABEL:
25058           case MODIFY:
25059           case MOD:
25060           case MODE:
25061           case MONTH:
25062           case NATURAL:
25063           case NATURALN:
25064           case NEW:
25065           case NEXTVAL:
25066           case NO:
25067           case NOCOPY:
25068           case NONEDITIONABLE:
25069           case NOT:
25070           case NOWAIT:
25071           case NULL:
25072           case NULLIF:
25073           case NUMBER:
25074           case BFILE_BASE:
25075           case BLOB_BASE:
25076           case CLOB_BASE:
25077           case DATE_BASE:
25078           case NUMBER_BASE:
25079           case OBJECT:
25080           case OCIROWID:
25081           case OF:
25082           case OID:
25083           case ON:
25084           case OPAQUE:
25085           case OPEN:
25086           case OPERATOR:
25087           case OPTION:
25088           case OR:
25089           case ORDER:
25090           case ORGANIZATION:
25091           case OTHERS:
25092           case OUT:
25093           case OVERRIDING:
25094           case PACKAGE:
25095           case PARTITION:
25096           case PCTFREE:
25097           case PLS_INTEGER:
25098           case POSITIVE:
25099           case POSITIVEN:
25100           case PRAGMA:
25101           case PRESERVE:
25102           case PRIOR:
25103           case PROMPT:
25104           case PRIVATE:
25105           case PROCEDURE:
25106           case PUBLIC:
25107           case RAISE:
25108           case RANGE:
25109           case RAW:
25110           case REAL:
25111           case RECORD:
25112           case REF:
25113           case RELEASE:
25114           case RELIES_ON:
25115           case RENAME:
25116           case RESULT:
25117           case RETURN:
25118           case RETURNING:
25119           case REVERSE:
25120           case ROLLBACK:
25121           case ROW:
25122           case ROWS:
25123           case ROWID:
25124           case ROWNUM:
25125           case ROWTYPE:
25126           case SAVE:
25127           case SAVEPOINT:
25128           case SECOND:
25129           case SELECT:
25130           case SELF:
25131           case SEPARATE:
25132           case SET:
25133           case SHARE:
25134           case SMALLINT:
25135           case SPACE:
25136           case SQL:
25137           case SQLCODE:
25138           case SQLERRM:
25139           case START:
25140           case STATIC:
25141           case STDDEV:
25142           case SUBTYPE:
25143           case SUBSTITUTABLE:
25144           case SUCCESSFUL:
25145           case SUM:
25146           case SYNONYM:
25147           case SYSDATE:
25148           case SYS_REFCURSOR:
25149           case TABLE:
25150           case TEMPORARY:
25151           case THEN:
25152           case TIME:
25153           case TIMESTAMP:
25154           case TIMEZONE_REGION:
25155           case TIMEZONE_ABBR:
25156           case TIMEZONE_MINUTE:
25157           case TIMEZONE_HOUR:
25158           case TO:
25159           case TRANSACTION:
25160           case TRIGGER:
25161           case TRUE:
25162           case TYPE:
25163           case UI:
25164           case UNDER:
25165           case USING:
25166           case WHILE:
25167           case YES:
25168           case SHOW:
25169           case A:
25170           case UPDATE:
25171           case VARCHAR:
25172           case VARCHAR2:
25173           case DOUBLE:
25174           case DEC:
25175           case PRECISION:
25176           case INT:
25177           case NUMERIC:
25178           case SIGNTYPE:
25179           case NCHAR:
25180           case NVARCHAR2:
25181           case STRING:
25182           case UROWID:
25183           case VARRAY:
25184           case VARYING:
25185           case BFILE:
25186           case BLOB:
25187           case CLOB:
25188           case NCLOB:
25189           case YEAR:
25190           case LOCAL:
25191           case WITH:
25192           case ZONE:
25193           case CHARACTER:
25194           case AFTER:
25195           case BEFORE:
25196           case OLD:
25197           case PARENT:
25198           case ANALYZE:
25199           case ASSOCIATE:
25200           case AUDIT:
25201           case COMPOUND:
25202           case DATABASE:
25203           case CALL:
25204           case DDL:
25205           case DISASSOCIATE:
25206           case EACH:
25207           case FOLLOWS:
25208           case LOGOFF:
25209           case LOGON:
25210           case NESTED:
25211           case NOAUDIT:
25212           case SCHEMA:
25213           case SERVERERROR:
25214           case SHUTDOWN:
25215           case STARTUP:
25216           case STATEMENT:
25217           case STATISTICS:
25218           case SUSPEND:
25219           case TRUNCATE:
25220           case WRAPPED:
25221           case LIBRARY:
25222           case NAME:
25223           case STRUCT:
25224           case CONTEXT:
25225           case PARAMETERS:
25226           case LENGTH:
25227           case TDO:
25228           case MAXLEN:
25229           case CHARSETID:
25230           case CHARSETFORM:
25231           case ACCEPT:
25232           case ACCESSIBLE:
25233           case COPY:
25234           case DEFINE:
25235           case DISCONNECT:
25236           case HOST:
25237           case PRINT:
25238           case QUIT:
25239           case REMARK:
25240           case UNDEFINE:
25241           case VARIABLE:
25242           case WHENEVER:
25243           case ATTACH:
25244           case CAST:
25245           case TREAT:
25246           case TRIM:
25247           case LEFT:
25248           case RIGHT:
25249           case BOTH:
25250           case EMPTY:
25251           case MULTISET:
25252           case SUBMULTISET:
25253           case LEADING:
25254           case TRAILING:
25255           case CHAR_CS:
25256           case NCHAR_CS:
25257           case DBTIMEZONE:
25258           case SESSIONTIMEZONE:
25259           case AUTHENTICATED:
25260           case LINK:
25261           case SHARED:
25262           case DIRECTORY:
25263           case USER:
25264           case IDENTIFIER:
25265           case QUOTED_LITERAL:
25266           case SQLDATA_CLASS:
25267           case CUSTOMDATUM_CLASS:
25268           case ORADATA_CLASS:
25269           case JAVA_INTERFACE_CLASS:
25270             ;
25271             break;
25272           default:
25273             jj_la1[358] = jj_gen;
25274             break label_76;
25275           }
25276           if (jj_2_69(2)) {
25277             TypeMethod();
25278           } else {
25279             switch (jj_nt.kind) {
25280             case REPLACE:
25281             case DEFINER:
25282             case CURRENT_USER:
25283             case SERIALLY_REUSABLE:
25284             case RESTRICT_REFERENCES:
25285             case EXCEPTION_INIT:
25286             case AUTONOMOUS_TRANSACTION:
25287             case LANGUAGE:
25288             case INLINE:
25289             case ADD:
25290             case AGGREGATE:
25291             case ALL:
25292             case ALTER:
25293             case AND:
25294             case ANY:
25295             case ARRAY:
25296             case AS:
25297             case ASC:
25298             case AT:
25299             case ATTRIBUTE:
25300             case AUTHID:
25301             case AVG:
25302             case BETWEEN:
25303             case BINARY_INTEGER:
25304             case BODY:
25305             case BOOLEAN:
25306             case BULK:
25307             case BY:
25308             case BYTE:
25309             case CASCADE:
25310             case CASE:
25311             case CHAR:
25312             case CHAR_BASE:
25313             case CHECK:
25314             case CLOSE:
25315             case CLUSTER:
25316             case COALESCE:
25317             case COLLECT:
25318             case COLUMN:
25319             case COMMENT:
25320             case COMMIT:
25321             case COMPRESS:
25322             case CONNECT:
25323             case CONSTANT:
25324             case CONSTRUCTOR:
25325             case CONTINUE:
25326             case CONVERT:
25327             case CREATE:
25328             case CURRENT:
25329             case CURRVAL:
25330             case CURSOR:
25331             case DATA:
25332             case DATE:
25333             case DAY:
25334             case DECLARE:
25335             case DECIMAL:
25336             case _DEFAULT:
25337             case DELETE:
25338             case DESC:
25339             case DISABLE:
25340             case DISTINCT:
25341             case DO:
25342             case DROP:
25343             case EDITIONABLE:
25344             case ELEMENT:
25345             case ELSE:
25346             case ELSIF:
25347             case ENABLE:
25348             case ESCAPE:
25349             case EXCEPT:
25350             case EXCEPTION:
25351             case EXCEPTIONS:
25352             case EXCLUSIVE:
25353             case EXECUTE:
25354             case EXISTS:
25355             case EXIT:
25356             case EXTERNAL:
25357             case EXTENDS:
25358             case EXTRACT:
25359             case FALSE:
25360             case FETCH:
25361             case FINAL:
25362             case FLOAT:
25363             case FOR:
25364             case FORALL:
25365             case FORCE:
25366             case FROM:
25367             case FUNCTION:
25368             case GLOBAL:
25369             case GOTO:
25370             case GROUP:
25371             case HASH:
25372             case HAVING:
25373             case HEAP:
25374             case HOUR:
25375             case IF:
25376             case IMMEDIATE:
25377             case IN:
25378             case INDEX:
25379             case INDICES:
25380             case INDEXTYPE:
25381             case INDICATOR:
25382             case INSERT:
25383             case INSTANTIABLE:
25384             case INTEGER:
25385             case INTERFACE:
25386             case INTERSECT:
25387             case INTERVAL:
25388             case INTO:
25389             case INVALIDATE:
25390             case IS:
25391             case ISOLATION:
25392             case JAVA:
25393             case LEVEL:
25394             case LIKE:
25395             case LIMIT:
25396             case LIMITED:
25397             case LOCK:
25398             case LONG:
25399             case LOOP:
25400             case MAP:
25401             case MAX:
25402             case MEMBER:
25403             case MERGE:
25404             case MIN:
25405             case MINUS:
25406             case MINUTE:
25407             case MLSLABEL:
25408             case MODIFY:
25409             case MOD:
25410             case MODE:
25411             case MONTH:
25412             case NATURAL:
25413             case NATURALN:
25414             case NEW:
25415             case NEXTVAL:
25416             case NO:
25417             case NOCOPY:
25418             case NONEDITIONABLE:
25419             case NOT:
25420             case NOWAIT:
25421             case NULL:
25422             case NULLIF:
25423             case NUMBER:
25424             case BFILE_BASE:
25425             case BLOB_BASE:
25426             case CLOB_BASE:
25427             case DATE_BASE:
25428             case NUMBER_BASE:
25429             case OBJECT:
25430             case OCIROWID:
25431             case OF:
25432             case OID:
25433             case ON:
25434             case OPAQUE:
25435             case OPEN:
25436             case OPERATOR:
25437             case OPTION:
25438             case OR:
25439             case ORDER:
25440             case ORGANIZATION:
25441             case OTHERS:
25442             case OUT:
25443             case OVERRIDING:
25444             case PACKAGE:
25445             case PARTITION:
25446             case PCTFREE:
25447             case PLS_INTEGER:
25448             case POSITIVE:
25449             case POSITIVEN:
25450             case PRESERVE:
25451             case PRIOR:
25452             case PROMPT:
25453             case PRIVATE:
25454             case PROCEDURE:
25455             case PUBLIC:
25456             case RAISE:
25457             case RANGE:
25458             case RAW:
25459             case REAL:
25460             case RECORD:
25461             case REF:
25462             case RELEASE:
25463             case RELIES_ON:
25464             case RENAME:
25465             case RESULT:
25466             case RETURN:
25467             case RETURNING:
25468             case REVERSE:
25469             case ROLLBACK:
25470             case ROW:
25471             case ROWS:
25472             case ROWID:
25473             case ROWNUM:
25474             case ROWTYPE:
25475             case SAVE:
25476             case SAVEPOINT:
25477             case SECOND:
25478             case SELECT:
25479             case SELF:
25480             case SEPARATE:
25481             case SET:
25482             case SHARE:
25483             case SMALLINT:
25484             case SPACE:
25485             case SQL:
25486             case SQLCODE:
25487             case SQLERRM:
25488             case START:
25489             case STATIC:
25490             case STDDEV:
25491             case SUBTYPE:
25492             case SUBSTITUTABLE:
25493             case SUCCESSFUL:
25494             case SUM:
25495             case SYNONYM:
25496             case SYSDATE:
25497             case SYS_REFCURSOR:
25498             case TABLE:
25499             case TEMPORARY:
25500             case THEN:
25501             case TIME:
25502             case TIMESTAMP:
25503             case TIMEZONE_REGION:
25504             case TIMEZONE_ABBR:
25505             case TIMEZONE_MINUTE:
25506             case TIMEZONE_HOUR:
25507             case TO:
25508             case TRANSACTION:
25509             case TRIGGER:
25510             case TRUE:
25511             case TYPE:
25512             case UI:
25513             case UNDER:
25514             case USING:
25515             case WHILE:
25516             case YES:
25517             case SHOW:
25518             case A:
25519             case UPDATE:
25520             case VARCHAR:
25521             case VARCHAR2:
25522             case DOUBLE:
25523             case DEC:
25524             case PRECISION:
25525             case INT:
25526             case NUMERIC:
25527             case SIGNTYPE:
25528             case NCHAR:
25529             case NVARCHAR2:
25530             case STRING:
25531             case UROWID:
25532             case VARRAY:
25533             case VARYING:
25534             case BFILE:
25535             case BLOB:
25536             case CLOB:
25537             case NCLOB:
25538             case YEAR:
25539             case LOCAL:
25540             case WITH:
25541             case ZONE:
25542             case CHARACTER:
25543             case AFTER:
25544             case BEFORE:
25545             case OLD:
25546             case PARENT:
25547             case ANALYZE:
25548             case ASSOCIATE:
25549             case AUDIT:
25550             case COMPOUND:
25551             case DATABASE:
25552             case CALL:
25553             case DDL:
25554             case DISASSOCIATE:
25555             case EACH:
25556             case FOLLOWS:
25557             case LOGOFF:
25558             case LOGON:
25559             case NESTED:
25560             case NOAUDIT:
25561             case SCHEMA:
25562             case SERVERERROR:
25563             case SHUTDOWN:
25564             case STARTUP:
25565             case STATEMENT:
25566             case STATISTICS:
25567             case SUSPEND:
25568             case TRUNCATE:
25569             case WRAPPED:
25570             case LIBRARY:
25571             case NAME:
25572             case STRUCT:
25573             case CONTEXT:
25574             case PARAMETERS:
25575             case LENGTH:
25576             case TDO:
25577             case MAXLEN:
25578             case CHARSETID:
25579             case CHARSETFORM:
25580             case ACCEPT:
25581             case ACCESSIBLE:
25582             case COPY:
25583             case DEFINE:
25584             case DISCONNECT:
25585             case HOST:
25586             case PRINT:
25587             case QUIT:
25588             case REMARK:
25589             case UNDEFINE:
25590             case VARIABLE:
25591             case WHENEVER:
25592             case ATTACH:
25593             case CAST:
25594             case TREAT:
25595             case TRIM:
25596             case LEFT:
25597             case RIGHT:
25598             case BOTH:
25599             case EMPTY:
25600             case MULTISET:
25601             case SUBMULTISET:
25602             case LEADING:
25603             case TRAILING:
25604             case CHAR_CS:
25605             case NCHAR_CS:
25606             case DBTIMEZONE:
25607             case SESSIONTIMEZONE:
25608             case AUTHENTICATED:
25609             case LINK:
25610             case SHARED:
25611             case DIRECTORY:
25612             case USER:
25613             case IDENTIFIER:
25614             case QUOTED_LITERAL:
25615             case SQLDATA_CLASS:
25616             case CUSTOMDATUM_CLASS:
25617             case ORADATA_CLASS:
25618             case JAVA_INTERFACE_CLASS:
25619               AttributeDeclaration();
25620               break;
25621             case PRAGMA:
25622               PragmaClause();
25623               break;
25624             default:
25625               jj_la1[359] = jj_gen;
25626               jj_consume_token(-1);
25627               throw new ParseException();
25628             }
25629           }
25630         }
25631         label_77:
25632         while (true) {
25633           switch (jj_nt.kind) {
25634           case 6:
25635             ;
25636             break;
25637           default:
25638             jj_la1[360] = jj_gen;
25639             break label_77;
25640           }
25641           jj_consume_token(6);
25642           switch (jj_nt.kind) {
25643           case CONSTRUCTOR:
25644           case FINAL:
25645           case INSTANTIABLE:
25646           case MAP:
25647           case MEMBER:
25648           case NOT:
25649           case ORDER:
25650           case OVERRIDING:
25651           case STATIC:
25652             TypeMethod();
25653             break;
25654           default:
25655             jj_la1[361] = jj_gen;
25656             if (jj_2_70(2)) {
25657               AttributeDeclaration();
25658             } else {
25659               switch (jj_nt.kind) {
25660               case PRAGMA:
25661                 PragmaClause();
25662                 break;
25663               default:
25664                 jj_la1[362] = jj_gen;
25665                 jj_consume_token(-1);
25666                 throw new ParseException();
25667               }
25668             }
25669           }
25670         }
25671         jj_consume_token(7);
25672         break;
25673       default:
25674         jj_la1[363] = jj_gen;
25675         ;
25676       }
25677       label_78:
25678       while (true) {
25679         switch (jj_nt.kind) {
25680         case FINAL:
25681         case INSTANTIABLE:
25682         case NOT:
25683         case NULL:
25684           ;
25685           break;
25686         default:
25687           jj_la1[364] = jj_gen;
25688           break label_78;
25689         }
25690         switch (jj_nt.kind) {
25691         case NOT:
25692           jj_consume_token(NOT);
25693           break;
25694         default:
25695           jj_la1[365] = jj_gen;
25696           ;
25697         }
25698         switch (jj_nt.kind) {
25699         case FINAL:
25700           jj_consume_token(FINAL);
25701           break;
25702         case INSTANTIABLE:
25703           jj_consume_token(INSTANTIABLE);
25704           break;
25705         case NULL:
25706           jj_consume_token(NULL);
25707           break;
25708         default:
25709           jj_la1[366] = jj_gen;
25710           jj_consume_token(-1);
25711           throw new ParseException();
25712         }
25713       }
25714       label_79:
25715       while (true) {
25716         switch (jj_nt.kind) {
25717         case ALTER:
25718           ;
25719           break;
25720         default:
25721           jj_la1[367] = jj_gen;
25722           break label_79;
25723         }
25724         AlterTypeSpec();
25725       }
25726       switch (jj_nt.kind) {
25727       case 1:
25728       case 4:
25729         switch (jj_nt.kind) {
25730         case 4:
25731           jj_consume_token(4);
25732           break;
25733         case 1:
25734           jj_consume_token(1);
25735           break;
25736         default:
25737           jj_la1[368] = jj_gen;
25738           jj_consume_token(-1);
25739           throw new ParseException();
25740         }
25741         label_80:
25742         while (true) {
25743           switch (jj_nt.kind) {
25744           case ALTER:
25745             ;
25746             break;
25747           default:
25748             jj_la1[369] = jj_gen;
25749             break label_80;
25750           }
25751           AlterTypeSpec();
25752           switch (jj_nt.kind) {
25753           case 1:
25754             jj_consume_token(1);
25755             break;
25756           case 4:
25757             jj_consume_token(4);
25758             break;
25759           default:
25760             jj_la1[370] = jj_gen;
25761             jj_consume_token(-1);
25762             throw new ParseException();
25763           }
25764         }
25765         break;
25766       default:
25767         jj_la1[371] = jj_gen;
25768         ;
25769       }
25770         jjtree.closeNodeScope(jjtn000, true);
25771         jjtc000 = false;
25772         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
25773     } catch (Throwable jjte000) {
25774           if (jjtc000) {
25775             jjtree.clearNodeScope(jjtn000);
25776             jjtc000 = false;
25777           } else {
25778             jjtree.popNode();
25779           }
25780           if (jjte000 instanceof RuntimeException) {
25781             {if (true) throw (RuntimeException)jjte000;}
25782           }
25783           if (jjte000 instanceof ParseException) {
25784             {if (true) throw (ParseException)jjte000;}
25785           }
25786           {if (true) throw (Error)jjte000;}
25787     } finally {
25788           if (jjtc000) {
25789             jjtree.closeNodeScope(jjtn000, true);
25790           }
25791     }
25792     throw new Error("Missing return statement in function");
25793   }
25794 
25795   final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
25796  /*@bgen(jjtree) AlterTypeSpec */
25797  ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
25798  boolean jjtc000 = true;
25799  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
25800     try {
25801       jj_consume_token(ALTER);
25802       jj_consume_token(TYPE);
25803       simpleNode = QualifiedName();
25804       label_81:
25805       while (true) {
25806         switch (jj_nt.kind) {
25807         case 6:
25808         case ADD:
25809         case DROP:
25810         case MODIFY:
25811           ;
25812           break;
25813         default:
25814           jj_la1[372] = jj_gen;
25815           break label_81;
25816         }
25817         switch (jj_nt.kind) {
25818         case 6:
25819         case ADD:
25820         case MODIFY:
25821           switch (jj_nt.kind) {
25822           case 6:
25823             jj_consume_token(6);
25824             break;
25825           default:
25826             jj_la1[373] = jj_gen;
25827             ;
25828           }
25829           switch (jj_nt.kind) {
25830           case ADD:
25831             jj_consume_token(ADD);
25832             break;
25833           case MODIFY:
25834             jj_consume_token(MODIFY);
25835             break;
25836           default:
25837             jj_la1[374] = jj_gen;
25838             jj_consume_token(-1);
25839             throw new ParseException();
25840           }
25841           label_82:
25842           while (true) {
25843             switch (jj_nt.kind) {
25844             case CONSTRUCTOR:
25845             case FINAL:
25846             case INSTANTIABLE:
25847             case MAP:
25848             case MEMBER:
25849             case NOT:
25850             case ORDER:
25851             case OVERRIDING:
25852             case STATIC:
25853               TypeMethod();
25854               break;
25855             case ATTRIBUTE:
25856               jj_consume_token(ATTRIBUTE);
25857               label_83:
25858               while (true) {
25859                 switch (jj_nt.kind) {
25860                 case 5:
25861                   ;
25862                   break;
25863                 default:
25864                   jj_la1[375] = jj_gen;
25865                   break label_83;
25866                 }
25867                 jj_consume_token(5);
25868               }
25869               AttributeDeclaration();
25870               label_84:
25871               while (true) {
25872                 switch (jj_nt.kind) {
25873                 case 6:
25874                   ;
25875                   break;
25876                 default:
25877                   jj_la1[376] = jj_gen;
25878                   break label_84;
25879                 }
25880                 jj_consume_token(6);
25881                 AttributeDeclaration();
25882               }
25883               label_85:
25884               while (true) {
25885                 switch (jj_nt.kind) {
25886                 case 7:
25887                   ;
25888                   break;
25889                 default:
25890                   jj_la1[377] = jj_gen;
25891                   break label_85;
25892                 }
25893                 jj_consume_token(7);
25894               }
25895               break;
25896             case LIMIT:
25897               jj_consume_token(LIMIT);
25898               NumericLiteral();
25899               break;
25900             case ELEMENT:
25901               jj_consume_token(ELEMENT);
25902               jj_consume_token(TYPE);
25903               Datatype();
25904               break;
25905             default:
25906               jj_la1[378] = jj_gen;
25907               jj_consume_token(-1);
25908               throw new ParseException();
25909             }
25910             switch (jj_nt.kind) {
25911             case ATTRIBUTE:
25912             case CONSTRUCTOR:
25913             case ELEMENT:
25914             case FINAL:
25915             case INSTANTIABLE:
25916             case LIMIT:
25917             case MAP:
25918             case MEMBER:
25919             case NOT:
25920             case ORDER:
25921             case OVERRIDING:
25922             case STATIC:
25923               ;
25924               break;
25925             default:
25926               jj_la1[379] = jj_gen;
25927               break label_82;
25928             }
25929           }
25930           break;
25931         case DROP:
25932           jj_consume_token(DROP);
25933           label_86:
25934           while (true) {
25935             switch (jj_nt.kind) {
25936             case ATTRIBUTE:
25937               jj_consume_token(ATTRIBUTE);
25938               label_87:
25939               while (true) {
25940                 switch (jj_nt.kind) {
25941                 case 5:
25942                   ;
25943                   break;
25944                 default:
25945                   jj_la1[380] = jj_gen;
25946                   break label_87;
25947                 }
25948                 jj_consume_token(5);
25949               }
25950               Attribute();
25951               label_88:
25952               while (true) {
25953                 switch (jj_nt.kind) {
25954                 case 6:
25955                   ;
25956                   break;
25957                 default:
25958                   jj_la1[381] = jj_gen;
25959                   break label_88;
25960                 }
25961                 jj_consume_token(6);
25962                 Attribute();
25963               }
25964               label_89:
25965               while (true) {
25966                 switch (jj_nt.kind) {
25967                 case 7:
25968                   ;
25969                   break;
25970                 default:
25971                   jj_la1[382] = jj_gen;
25972                   break label_89;
25973                 }
25974                 jj_consume_token(7);
25975               }
25976               break;
25977             case CONSTRUCTOR:
25978             case FINAL:
25979             case INSTANTIABLE:
25980             case MAP:
25981             case MEMBER:
25982             case NOT:
25983             case ORDER:
25984             case OVERRIDING:
25985             case STATIC:
25986               TypeMethod();
25987               break;
25988             default:
25989               jj_la1[383] = jj_gen;
25990               jj_consume_token(-1);
25991               throw new ParseException();
25992             }
25993             switch (jj_nt.kind) {
25994             case ATTRIBUTE:
25995             case CONSTRUCTOR:
25996             case FINAL:
25997             case INSTANTIABLE:
25998             case MAP:
25999             case MEMBER:
26000             case NOT:
26001             case ORDER:
26002             case OVERRIDING:
26003             case STATIC:
26004               ;
26005               break;
26006             default:
26007               jj_la1[384] = jj_gen;
26008               break label_86;
26009             }
26010           }
26011           break;
26012         default:
26013           jj_la1[385] = jj_gen;
26014           jj_consume_token(-1);
26015           throw new ParseException();
26016         }
26017       }
26018       switch (jj_nt.kind) {
26019       case REPLACE:
26020         jj_consume_token(REPLACE);
26021         label_90:
26022         while (true) {
26023           if (jj_2_71(2)) {
26024             ;
26025           } else {
26026             break label_90;
26027           }
26028           switch (jj_nt.kind) {
26029           case AUTHID:
26030             jj_consume_token(AUTHID);
26031             switch (jj_nt.kind) {
26032             case CURRENT_USER:
26033               jj_consume_token(CURRENT_USER);
26034               break;
26035             case DEFINER:
26036               jj_consume_token(DEFINER);
26037               break;
26038             default:
26039               jj_la1[386] = jj_gen;
26040               jj_consume_token(-1);
26041               throw new ParseException();
26042             }
26043             break;
26044           case ACCESSIBLE:
26045             AccessibleByClause();
26046             break;
26047           default:
26048             jj_la1[387] = jj_gen;
26049             jj_consume_token(-1);
26050             throw new ParseException();
26051           }
26052         }
26053         switch (jj_nt.kind) {
26054         case IS:
26055           jj_consume_token(IS);
26056           break;
26057         case AS:
26058           jj_consume_token(AS);
26059           break;
26060         default:
26061           jj_la1[388] = jj_gen;
26062           jj_consume_token(-1);
26063           throw new ParseException();
26064         }
26065         jj_consume_token(OBJECT);
26066         jj_consume_token(5);
26067         if (jj_2_72(2)) {
26068           TypeMethod();
26069         } else {
26070           switch (jj_nt.kind) {
26071           case REPLACE:
26072           case DEFINER:
26073           case CURRENT_USER:
26074           case SERIALLY_REUSABLE:
26075           case RESTRICT_REFERENCES:
26076           case EXCEPTION_INIT:
26077           case AUTONOMOUS_TRANSACTION:
26078           case LANGUAGE:
26079           case INLINE:
26080           case ADD:
26081           case AGGREGATE:
26082           case ALL:
26083           case ALTER:
26084           case AND:
26085           case ANY:
26086           case ARRAY:
26087           case AS:
26088           case ASC:
26089           case AT:
26090           case ATTRIBUTE:
26091           case AUTHID:
26092           case AVG:
26093           case BETWEEN:
26094           case BINARY_INTEGER:
26095           case BODY:
26096           case BOOLEAN:
26097           case BULK:
26098           case BY:
26099           case BYTE:
26100           case CASCADE:
26101           case CASE:
26102           case CHAR:
26103           case CHAR_BASE:
26104           case CHECK:
26105           case CLOSE:
26106           case CLUSTER:
26107           case COALESCE:
26108           case COLLECT:
26109           case COLUMN:
26110           case COMMENT:
26111           case COMMIT:
26112           case COMPRESS:
26113           case CONNECT:
26114           case CONSTANT:
26115           case CONSTRUCTOR:
26116           case CONTINUE:
26117           case CONVERT:
26118           case CREATE:
26119           case CURRENT:
26120           case CURRVAL:
26121           case CURSOR:
26122           case DATA:
26123           case DATE:
26124           case DAY:
26125           case DECLARE:
26126           case DECIMAL:
26127           case _DEFAULT:
26128           case DELETE:
26129           case DESC:
26130           case DISABLE:
26131           case DISTINCT:
26132           case DO:
26133           case DROP:
26134           case EDITIONABLE:
26135           case ELEMENT:
26136           case ELSE:
26137           case ELSIF:
26138           case ENABLE:
26139           case ESCAPE:
26140           case EXCEPT:
26141           case EXCEPTION:
26142           case EXCEPTIONS:
26143           case EXCLUSIVE:
26144           case EXECUTE:
26145           case EXISTS:
26146           case EXIT:
26147           case EXTERNAL:
26148           case EXTENDS:
26149           case EXTRACT:
26150           case FALSE:
26151           case FETCH:
26152           case FINAL:
26153           case FLOAT:
26154           case FOR:
26155           case FORALL:
26156           case FORCE:
26157           case FROM:
26158           case FUNCTION:
26159           case GLOBAL:
26160           case GOTO:
26161           case GROUP:
26162           case HASH:
26163           case HAVING:
26164           case HEAP:
26165           case HOUR:
26166           case IF:
26167           case IMMEDIATE:
26168           case IN:
26169           case INDEX:
26170           case INDICES:
26171           case INDEXTYPE:
26172           case INDICATOR:
26173           case INSERT:
26174           case INSTANTIABLE:
26175           case INTEGER:
26176           case INTERFACE:
26177           case INTERSECT:
26178           case INTERVAL:
26179           case INTO:
26180           case INVALIDATE:
26181           case IS:
26182           case ISOLATION:
26183           case JAVA:
26184           case LEVEL:
26185           case LIKE:
26186           case LIMIT:
26187           case LIMITED:
26188           case LOCK:
26189           case LONG:
26190           case LOOP:
26191           case MAP:
26192           case MAX:
26193           case MEMBER:
26194           case MERGE:
26195           case MIN:
26196           case MINUS:
26197           case MINUTE:
26198           case MLSLABEL:
26199           case MODIFY:
26200           case MOD:
26201           case MODE:
26202           case MONTH:
26203           case NATURAL:
26204           case NATURALN:
26205           case NEW:
26206           case NEXTVAL:
26207           case NO:
26208           case NOCOPY:
26209           case NONEDITIONABLE:
26210           case NOT:
26211           case NOWAIT:
26212           case NULL:
26213           case NULLIF:
26214           case NUMBER:
26215           case BFILE_BASE:
26216           case BLOB_BASE:
26217           case CLOB_BASE:
26218           case DATE_BASE:
26219           case NUMBER_BASE:
26220           case OBJECT:
26221           case OCIROWID:
26222           case OF:
26223           case OID:
26224           case ON:
26225           case OPAQUE:
26226           case OPEN:
26227           case OPERATOR:
26228           case OPTION:
26229           case OR:
26230           case ORDER:
26231           case ORGANIZATION:
26232           case OTHERS:
26233           case OUT:
26234           case OVERRIDING:
26235           case PACKAGE:
26236           case PARTITION:
26237           case PCTFREE:
26238           case PLS_INTEGER:
26239           case POSITIVE:
26240           case POSITIVEN:
26241           case PRESERVE:
26242           case PRIOR:
26243           case PROMPT:
26244           case PRIVATE:
26245           case PROCEDURE:
26246           case PUBLIC:
26247           case RAISE:
26248           case RANGE:
26249           case RAW:
26250           case REAL:
26251           case RECORD:
26252           case REF:
26253           case RELEASE:
26254           case RELIES_ON:
26255           case RENAME:
26256           case RESULT:
26257           case RETURN:
26258           case RETURNING:
26259           case REVERSE:
26260           case ROLLBACK:
26261           case ROW:
26262           case ROWS:
26263           case ROWID:
26264           case ROWNUM:
26265           case ROWTYPE:
26266           case SAVE:
26267           case SAVEPOINT:
26268           case SECOND:
26269           case SELECT:
26270           case SELF:
26271           case SEPARATE:
26272           case SET:
26273           case SHARE:
26274           case SMALLINT:
26275           case SPACE:
26276           case SQL:
26277           case SQLCODE:
26278           case SQLERRM:
26279           case START:
26280           case STATIC:
26281           case STDDEV:
26282           case SUBTYPE:
26283           case SUBSTITUTABLE:
26284           case SUCCESSFUL:
26285           case SUM:
26286           case SYNONYM:
26287           case SYSDATE:
26288           case SYS_REFCURSOR:
26289           case TABLE:
26290           case TEMPORARY:
26291           case THEN:
26292           case TIME:
26293           case TIMESTAMP:
26294           case TIMEZONE_REGION:
26295           case TIMEZONE_ABBR:
26296           case TIMEZONE_MINUTE:
26297           case TIMEZONE_HOUR:
26298           case TO:
26299           case TRANSACTION:
26300           case TRIGGER:
26301           case TRUE:
26302           case TYPE:
26303           case UI:
26304           case UNDER:
26305           case USING:
26306           case WHILE:
26307           case YES:
26308           case SHOW:
26309           case A:
26310           case UPDATE:
26311           case VARCHAR:
26312           case VARCHAR2:
26313           case DOUBLE:
26314           case DEC:
26315           case PRECISION:
26316           case INT:
26317           case NUMERIC:
26318           case SIGNTYPE:
26319           case NCHAR:
26320           case NVARCHAR2:
26321           case STRING:
26322           case UROWID:
26323           case VARRAY:
26324           case VARYING:
26325           case BFILE:
26326           case BLOB:
26327           case CLOB:
26328           case NCLOB:
26329           case YEAR:
26330           case LOCAL:
26331           case WITH:
26332           case ZONE:
26333           case CHARACTER:
26334           case AFTER:
26335           case BEFORE:
26336           case OLD:
26337           case PARENT:
26338           case ANALYZE:
26339           case ASSOCIATE:
26340           case AUDIT:
26341           case COMPOUND:
26342           case DATABASE:
26343           case CALL:
26344           case DDL:
26345           case DISASSOCIATE:
26346           case EACH:
26347           case FOLLOWS:
26348           case LOGOFF:
26349           case LOGON:
26350           case NESTED:
26351           case NOAUDIT:
26352           case SCHEMA:
26353           case SERVERERROR:
26354           case SHUTDOWN:
26355           case STARTUP:
26356           case STATEMENT:
26357           case STATISTICS:
26358           case SUSPEND:
26359           case TRUNCATE:
26360           case WRAPPED:
26361           case LIBRARY:
26362           case NAME:
26363           case STRUCT:
26364           case CONTEXT:
26365           case PARAMETERS:
26366           case LENGTH:
26367           case TDO:
26368           case MAXLEN:
26369           case CHARSETID:
26370           case CHARSETFORM:
26371           case ACCEPT:
26372           case ACCESSIBLE:
26373           case COPY:
26374           case DEFINE:
26375           case DISCONNECT:
26376           case HOST:
26377           case PRINT:
26378           case QUIT:
26379           case REMARK:
26380           case UNDEFINE:
26381           case VARIABLE:
26382           case WHENEVER:
26383           case ATTACH:
26384           case CAST:
26385           case TREAT:
26386           case TRIM:
26387           case LEFT:
26388           case RIGHT:
26389           case BOTH:
26390           case EMPTY:
26391           case MULTISET:
26392           case SUBMULTISET:
26393           case LEADING:
26394           case TRAILING:
26395           case CHAR_CS:
26396           case NCHAR_CS:
26397           case DBTIMEZONE:
26398           case SESSIONTIMEZONE:
26399           case AUTHENTICATED:
26400           case LINK:
26401           case SHARED:
26402           case DIRECTORY:
26403           case USER:
26404           case IDENTIFIER:
26405           case QUOTED_LITERAL:
26406           case SQLDATA_CLASS:
26407           case CUSTOMDATUM_CLASS:
26408           case ORADATA_CLASS:
26409           case JAVA_INTERFACE_CLASS:
26410             AttributeDeclaration();
26411             break;
26412           default:
26413             jj_la1[389] = jj_gen;
26414             jj_consume_token(-1);
26415             throw new ParseException();
26416           }
26417         }
26418         label_91:
26419         while (true) {
26420           switch (jj_nt.kind) {
26421           case 6:
26422             ;
26423             break;
26424           default:
26425             jj_la1[390] = jj_gen;
26426             break label_91;
26427           }
26428           jj_consume_token(6);
26429           if (jj_2_73(2)) {
26430             TypeMethod();
26431           } else {
26432             switch (jj_nt.kind) {
26433             case REPLACE:
26434             case DEFINER:
26435             case CURRENT_USER:
26436             case SERIALLY_REUSABLE:
26437             case RESTRICT_REFERENCES:
26438             case EXCEPTION_INIT:
26439             case AUTONOMOUS_TRANSACTION:
26440             case LANGUAGE:
26441             case INLINE:
26442             case ADD:
26443             case AGGREGATE:
26444             case ALL:
26445             case ALTER:
26446             case AND:
26447             case ANY:
26448             case ARRAY:
26449             case AS:
26450             case ASC:
26451             case AT:
26452             case ATTRIBUTE:
26453             case AUTHID:
26454             case AVG:
26455             case BETWEEN:
26456             case BINARY_INTEGER:
26457             case BODY:
26458             case BOOLEAN:
26459             case BULK:
26460             case BY:
26461             case BYTE:
26462             case CASCADE:
26463             case CASE:
26464             case CHAR:
26465             case CHAR_BASE:
26466             case CHECK:
26467             case CLOSE:
26468             case CLUSTER:
26469             case COALESCE:
26470             case COLLECT:
26471             case COLUMN:
26472             case COMMENT:
26473             case COMMIT:
26474             case COMPRESS:
26475             case CONNECT:
26476             case CONSTANT:
26477             case CONSTRUCTOR:
26478             case CONTINUE:
26479             case CONVERT:
26480             case CREATE:
26481             case CURRENT:
26482             case CURRVAL:
26483             case CURSOR:
26484             case DATA:
26485             case DATE:
26486             case DAY:
26487             case DECLARE:
26488             case DECIMAL:
26489             case _DEFAULT:
26490             case DELETE:
26491             case DESC:
26492             case DISABLE:
26493             case DISTINCT:
26494             case DO:
26495             case DROP:
26496             case EDITIONABLE:
26497             case ELEMENT:
26498             case ELSE:
26499             case ELSIF:
26500             case ENABLE:
26501             case ESCAPE:
26502             case EXCEPT:
26503             case EXCEPTION:
26504             case EXCEPTIONS:
26505             case EXCLUSIVE:
26506             case EXECUTE:
26507             case EXISTS:
26508             case EXIT:
26509             case EXTERNAL:
26510             case EXTENDS:
26511             case EXTRACT:
26512             case FALSE:
26513             case FETCH:
26514             case FINAL:
26515             case FLOAT:
26516             case FOR:
26517             case FORALL:
26518             case FORCE:
26519             case FROM:
26520             case FUNCTION:
26521             case GLOBAL:
26522             case GOTO:
26523             case GROUP:
26524             case HASH:
26525             case HAVING:
26526             case HEAP:
26527             case HOUR:
26528             case IF:
26529             case IMMEDIATE:
26530             case IN:
26531             case INDEX:
26532             case INDICES:
26533             case INDEXTYPE:
26534             case INDICATOR:
26535             case INSERT:
26536             case INSTANTIABLE:
26537             case INTEGER:
26538             case INTERFACE:
26539             case INTERSECT:
26540             case INTERVAL:
26541             case INTO:
26542             case INVALIDATE:
26543             case IS:
26544             case ISOLATION:
26545             case JAVA:
26546             case LEVEL:
26547             case LIKE:
26548             case LIMIT:
26549             case LIMITED:
26550             case LOCK:
26551             case LONG:
26552             case LOOP:
26553             case MAP:
26554             case MAX:
26555             case MEMBER:
26556             case MERGE:
26557             case MIN:
26558             case MINUS:
26559             case MINUTE:
26560             case MLSLABEL:
26561             case MODIFY:
26562             case MOD:
26563             case MODE:
26564             case MONTH:
26565             case NATURAL:
26566             case NATURALN:
26567             case NEW:
26568             case NEXTVAL:
26569             case NO:
26570             case NOCOPY:
26571             case NONEDITIONABLE:
26572             case NOT:
26573             case NOWAIT:
26574             case NULL:
26575             case NULLIF:
26576             case NUMBER:
26577             case BFILE_BASE:
26578             case BLOB_BASE:
26579             case CLOB_BASE:
26580             case DATE_BASE:
26581             case NUMBER_BASE:
26582             case OBJECT:
26583             case OCIROWID:
26584             case OF:
26585             case OID:
26586             case ON:
26587             case OPAQUE:
26588             case OPEN:
26589             case OPERATOR:
26590             case OPTION:
26591             case OR:
26592             case ORDER:
26593             case ORGANIZATION:
26594             case OTHERS:
26595             case OUT:
26596             case OVERRIDING:
26597             case PACKAGE:
26598             case PARTITION:
26599             case PCTFREE:
26600             case PLS_INTEGER:
26601             case POSITIVE:
26602             case POSITIVEN:
26603             case PRESERVE:
26604             case PRIOR:
26605             case PROMPT:
26606             case PRIVATE:
26607             case PROCEDURE:
26608             case PUBLIC:
26609             case RAISE:
26610             case RANGE:
26611             case RAW:
26612             case REAL:
26613             case RECORD:
26614             case REF:
26615             case RELEASE:
26616             case RELIES_ON:
26617             case RENAME:
26618             case RESULT:
26619             case RETURN:
26620             case RETURNING:
26621             case REVERSE:
26622             case ROLLBACK:
26623             case ROW:
26624             case ROWS:
26625             case ROWID:
26626             case ROWNUM:
26627             case ROWTYPE:
26628             case SAVE:
26629             case SAVEPOINT:
26630             case SECOND:
26631             case SELECT:
26632             case SELF:
26633             case SEPARATE:
26634             case SET:
26635             case SHARE:
26636             case SMALLINT:
26637             case SPACE:
26638             case SQL:
26639             case SQLCODE:
26640             case SQLERRM:
26641             case START:
26642             case STATIC:
26643             case STDDEV:
26644             case SUBTYPE:
26645             case SUBSTITUTABLE:
26646             case SUCCESSFUL:
26647             case SUM:
26648             case SYNONYM:
26649             case SYSDATE:
26650             case SYS_REFCURSOR:
26651             case TABLE:
26652             case TEMPORARY:
26653             case THEN:
26654             case TIME:
26655             case TIMESTAMP:
26656             case TIMEZONE_REGION:
26657             case TIMEZONE_ABBR:
26658             case TIMEZONE_MINUTE:
26659             case TIMEZONE_HOUR:
26660             case TO:
26661             case TRANSACTION:
26662             case TRIGGER:
26663             case TRUE:
26664             case TYPE:
26665             case UI:
26666             case UNDER:
26667             case USING:
26668             case WHILE:
26669             case YES:
26670             case SHOW:
26671             case A:
26672             case UPDATE:
26673             case VARCHAR:
26674             case VARCHAR2:
26675             case DOUBLE:
26676             case DEC:
26677             case PRECISION:
26678             case INT:
26679             case NUMERIC:
26680             case SIGNTYPE:
26681             case NCHAR:
26682             case NVARCHAR2:
26683             case STRING:
26684             case UROWID:
26685             case VARRAY:
26686             case VARYING:
26687             case BFILE:
26688             case BLOB:
26689             case CLOB:
26690             case NCLOB:
26691             case YEAR:
26692             case LOCAL:
26693             case WITH:
26694             case ZONE:
26695             case CHARACTER:
26696             case AFTER:
26697             case BEFORE:
26698             case OLD:
26699             case PARENT:
26700             case ANALYZE:
26701             case ASSOCIATE:
26702             case AUDIT:
26703             case COMPOUND:
26704             case DATABASE:
26705             case CALL:
26706             case DDL:
26707             case DISASSOCIATE:
26708             case EACH:
26709             case FOLLOWS:
26710             case LOGOFF:
26711             case LOGON:
26712             case NESTED:
26713             case NOAUDIT:
26714             case SCHEMA:
26715             case SERVERERROR:
26716             case SHUTDOWN:
26717             case STARTUP:
26718             case STATEMENT:
26719             case STATISTICS:
26720             case SUSPEND:
26721             case TRUNCATE:
26722             case WRAPPED:
26723             case LIBRARY:
26724             case NAME:
26725             case STRUCT:
26726             case CONTEXT:
26727             case PARAMETERS:
26728             case LENGTH:
26729             case TDO:
26730             case MAXLEN:
26731             case CHARSETID:
26732             case CHARSETFORM:
26733             case ACCEPT:
26734             case ACCESSIBLE:
26735             case COPY:
26736             case DEFINE:
26737             case DISCONNECT:
26738             case HOST:
26739             case PRINT:
26740             case QUIT:
26741             case REMARK:
26742             case UNDEFINE:
26743             case VARIABLE:
26744             case WHENEVER:
26745             case ATTACH:
26746             case CAST:
26747             case TREAT:
26748             case TRIM:
26749             case LEFT:
26750             case RIGHT:
26751             case BOTH:
26752             case EMPTY:
26753             case MULTISET:
26754             case SUBMULTISET:
26755             case LEADING:
26756             case TRAILING:
26757             case CHAR_CS:
26758             case NCHAR_CS:
26759             case DBTIMEZONE:
26760             case SESSIONTIMEZONE:
26761             case AUTHENTICATED:
26762             case LINK:
26763             case SHARED:
26764             case DIRECTORY:
26765             case USER:
26766             case IDENTIFIER:
26767             case QUOTED_LITERAL:
26768             case SQLDATA_CLASS:
26769             case CUSTOMDATUM_CLASS:
26770             case ORADATA_CLASS:
26771             case JAVA_INTERFACE_CLASS:
26772               AttributeDeclaration();
26773               break;
26774             default:
26775               jj_la1[391] = jj_gen;
26776               jj_consume_token(-1);
26777               throw new ParseException();
26778             }
26779           }
26780         }
26781         jj_consume_token(7);
26782         break;
26783       default:
26784         jj_la1[392] = jj_gen;
26785         ;
26786       }
26787       label_92:
26788       while (true) {
26789         switch (jj_nt.kind) {
26790         case FINAL:
26791         case INSTANTIABLE:
26792         case NOT:
26793         case NULL:
26794           ;
26795           break;
26796         default:
26797           jj_la1[393] = jj_gen;
26798           break label_92;
26799         }
26800         switch (jj_nt.kind) {
26801         case NOT:
26802           jj_consume_token(NOT);
26803           break;
26804         default:
26805           jj_la1[394] = jj_gen;
26806           ;
26807         }
26808         switch (jj_nt.kind) {
26809         case FINAL:
26810           jj_consume_token(FINAL);
26811           break;
26812         case INSTANTIABLE:
26813           jj_consume_token(INSTANTIABLE);
26814           break;
26815         case NULL:
26816           jj_consume_token(NULL);
26817           break;
26818         default:
26819           jj_la1[395] = jj_gen;
26820           jj_consume_token(-1);
26821           throw new ParseException();
26822         }
26823       }
26824       switch (jj_nt.kind) {
26825       case CASCADE:
26826       case INVALIDATE:
26827         switch (jj_nt.kind) {
26828         case INVALIDATE:
26829           jj_consume_token(INVALIDATE);
26830           break;
26831         case CASCADE:
26832           jj_consume_token(CASCADE);
26833           label_93:
26834           while (true) {
26835             switch (jj_nt.kind) {
26836             case CONVERT:
26837             case INCLUDING:
26838             case NOT:
26839               ;
26840               break;
26841             default:
26842               jj_la1[396] = jj_gen;
26843               break label_93;
26844             }
26845             switch (jj_nt.kind) {
26846             case INCLUDING:
26847             case NOT:
26848               switch (jj_nt.kind) {
26849               case NOT:
26850                 jj_consume_token(NOT);
26851                 break;
26852               default:
26853                 jj_la1[397] = jj_gen;
26854                 ;
26855               }
26856               jj_consume_token(INCLUDING);
26857               jj_consume_token(TABLE);
26858               jj_consume_token(DATA);
26859               break;
26860             case CONVERT:
26861               jj_consume_token(CONVERT);
26862               jj_consume_token(TO);
26863               jj_consume_token(SUBSTITUTABLE);
26864               break;
26865             default:
26866               jj_la1[398] = jj_gen;
26867               jj_consume_token(-1);
26868               throw new ParseException();
26869             }
26870           }
26871           switch (jj_nt.kind) {
26872           case EXCEPTIONS:
26873           case FORCE:
26874             switch (jj_nt.kind) {
26875             case FORCE:
26876               jj_consume_token(FORCE);
26877               break;
26878             default:
26879               jj_la1[399] = jj_gen;
26880               ;
26881             }
26882             jj_consume_token(EXCEPTIONS);
26883             jj_consume_token(INTO);
26884             QualifiedName();
26885             break;
26886           default:
26887             jj_la1[400] = jj_gen;
26888             ;
26889           }
26890           break;
26891         default:
26892           jj_la1[401] = jj_gen;
26893           jj_consume_token(-1);
26894           throw new ParseException();
26895         }
26896         break;
26897       default:
26898         jj_la1[402] = jj_gen;
26899         ;
26900       }
26901         jjtree.closeNodeScope(jjtn000, true);
26902         jjtc000 = false;
26903         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26904     } catch (Throwable jjte000) {
26905           if (jjtc000) {
26906             jjtree.clearNodeScope(jjtn000);
26907             jjtc000 = false;
26908           } else {
26909             jjtree.popNode();
26910           }
26911           if (jjte000 instanceof RuntimeException) {
26912             {if (true) throw (RuntimeException)jjte000;}
26913           }
26914           if (jjte000 instanceof ParseException) {
26915             {if (true) throw (ParseException)jjte000;}
26916           }
26917           {if (true) throw (Error)jjte000;}
26918     } finally {
26919           if (jjtc000) {
26920             jjtree.closeNodeScope(jjtn000, true);
26921           }
26922     }
26923     throw new Error("Missing return statement in function");
26924   }
26925 
26926 /*
26927 ASTTypeBody TypeBody()  :
26928 { Token name=null; }
26929 {
26930 	[<CREATE> [<OR> <REPLACE>]]
26931 
26932 	<TYPE> <BODY> (LOOKAHEAD(2) ID()".")? name=ID()
26933 
26934 	(
26935 	  (
26936 	    WrappedObject() 
26937 	  )
26938 	  |
26939 	  (
26940 	    (<IS> | <AS>)
26941 
26942 		    DeclarativeSection() //SRT 20110524 Allow PLDOc in Type Bodies 
26943 
26944 	    [ <BEGIN> (Statement())* (ExceptionHandler())? ] <END> [ID()] ";" 
26945 	  )
26946 	)
26947 }
26948 */
26949 
26950 
26951 /**
26952   * Method 
26953 **/
26954   final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26955  /*@bgen(jjtree) AttributeDeclaration */
26956  ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26957  boolean jjtc000 = true;
26958  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26959     try {
26960       simpleNode = ID();
26961       Datatype();
26962         jjtree.closeNodeScope(jjtn000, true);
26963         jjtc000 = false;
26964         jjtn000.setImage(simpleNode.getImage()) ;   {if (true) return jjtn000 ;}
26965     } catch (Throwable jjte000) {
26966           if (jjtc000) {
26967             jjtree.clearNodeScope(jjtn000);
26968             jjtc000 = false;
26969           } else {
26970             jjtree.popNode();
26971           }
26972           if (jjte000 instanceof RuntimeException) {
26973             {if (true) throw (RuntimeException)jjte000;}
26974           }
26975           if (jjte000 instanceof ParseException) {
26976             {if (true) throw (ParseException)jjte000;}
26977           }
26978           {if (true) throw (Error)jjte000;}
26979     } finally {
26980           if (jjtc000) {
26981             jjtree.closeNodeScope(jjtn000, true);
26982           }
26983     }
26984     throw new Error("Missing return statement in function");
26985   }
26986 
26987   final public ASTAttribute Attribute() throws ParseException {
26988  /*@bgen(jjtree) Attribute */
26989  ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26990  boolean jjtc000 = true;
26991  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26992     try {
26993       simpleNode = ID();
26994         jjtree.closeNodeScope(jjtn000, true);
26995         jjtc000 = false;
26996         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26997     } catch (Throwable jjte000) {
26998         if (jjtc000) {
26999           jjtree.clearNodeScope(jjtn000);
27000           jjtc000 = false;
27001         } else {
27002           jjtree.popNode();
27003         }
27004         if (jjte000 instanceof RuntimeException) {
27005           {if (true) throw (RuntimeException)jjte000;}
27006         }
27007         if (jjte000 instanceof ParseException) {
27008           {if (true) throw (ParseException)jjte000;}
27009         }
27010         {if (true) throw (Error)jjte000;}
27011     } finally {
27012         if (jjtc000) {
27013           jjtree.closeNodeScope(jjtn000, true);
27014         }
27015     }
27016     throw new Error("Missing return statement in function");
27017   }
27018 
27019 /*
27020  This was quick cut from PRAGMA
27021 */
27022   final public ASTPragmaClause PragmaClause() throws ParseException {
27023  /*@bgen(jjtree) PragmaClause */
27024   ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
27025   boolean jjtc000 = true;
27026   jjtree.openNodeScope(jjtn000);
27027     try {
27028       jj_consume_token(PRAGMA);
27029       switch (jj_nt.kind) {
27030       case SERIALLY_REUSABLE:
27031         jj_consume_token(SERIALLY_REUSABLE);
27032         break;
27033       case AUTONOMOUS_TRANSACTION:
27034         jj_consume_token(AUTONOMOUS_TRANSACTION);
27035         break;
27036       case RESTRICT_REFERENCES:
27037         jj_consume_token(RESTRICT_REFERENCES);
27038         jj_consume_token(5);
27039         ID();
27040         label_94:
27041         while (true) {
27042           jj_consume_token(6);
27043           switch (jj_nt.kind) {
27044           case REPLACE:
27045           case DEFINER:
27046           case CURRENT_USER:
27047           case SERIALLY_REUSABLE:
27048           case RESTRICT_REFERENCES:
27049           case EXCEPTION_INIT:
27050           case AUTONOMOUS_TRANSACTION:
27051           case LANGUAGE:
27052           case INLINE:
27053           case ADD:
27054           case AGGREGATE:
27055           case ALL:
27056           case ALTER:
27057           case AND:
27058           case ANY:
27059           case ARRAY:
27060           case AS:
27061           case ASC:
27062           case AT:
27063           case ATTRIBUTE:
27064           case AUTHID:
27065           case AVG:
27066           case BETWEEN:
27067           case BINARY_INTEGER:
27068           case BODY:
27069           case BOOLEAN:
27070           case BULK:
27071           case BY:
27072           case BYTE:
27073           case CASCADE:
27074           case CASE:
27075           case CHAR:
27076           case CHAR_BASE:
27077           case CHECK:
27078           case CLOSE:
27079           case CLUSTER:
27080           case COALESCE:
27081           case COLLECT:
27082           case COLUMN:
27083           case COMMENT:
27084           case COMMIT:
27085           case COMPRESS:
27086           case CONNECT:
27087           case CONSTANT:
27088           case CONSTRUCTOR:
27089           case CONTINUE:
27090           case CONVERT:
27091           case CREATE:
27092           case CURRENT:
27093           case CURRVAL:
27094           case CURSOR:
27095           case DATA:
27096           case DATE:
27097           case DAY:
27098           case DECLARE:
27099           case DECIMAL:
27100           case _DEFAULT:
27101           case DELETE:
27102           case DESC:
27103           case DISABLE:
27104           case DISTINCT:
27105           case DO:
27106           case DROP:
27107           case EDITIONABLE:
27108           case ELEMENT:
27109           case ELSE:
27110           case ELSIF:
27111           case ENABLE:
27112           case ESCAPE:
27113           case EXCEPT:
27114           case EXCEPTION:
27115           case EXCEPTIONS:
27116           case EXCLUSIVE:
27117           case EXECUTE:
27118           case EXISTS:
27119           case EXIT:
27120           case EXTERNAL:
27121           case EXTENDS:
27122           case EXTRACT:
27123           case FALSE:
27124           case FETCH:
27125           case FINAL:
27126           case FLOAT:
27127           case FOR:
27128           case FORALL:
27129           case FORCE:
27130           case FROM:
27131           case FUNCTION:
27132           case GLOBAL:
27133           case GOTO:
27134           case GROUP:
27135           case HASH:
27136           case HAVING:
27137           case HEAP:
27138           case HOUR:
27139           case IF:
27140           case IMMEDIATE:
27141           case IN:
27142           case INDEX:
27143           case INDICES:
27144           case INDEXTYPE:
27145           case INDICATOR:
27146           case INSERT:
27147           case INSTANTIABLE:
27148           case INTEGER:
27149           case INTERFACE:
27150           case INTERSECT:
27151           case INTERVAL:
27152           case INTO:
27153           case INVALIDATE:
27154           case IS:
27155           case ISOLATION:
27156           case JAVA:
27157           case LEVEL:
27158           case LIKE:
27159           case LIMIT:
27160           case LIMITED:
27161           case LOCK:
27162           case LONG:
27163           case LOOP:
27164           case MAP:
27165           case MAX:
27166           case MEMBER:
27167           case MERGE:
27168           case MIN:
27169           case MINUS:
27170           case MINUTE:
27171           case MLSLABEL:
27172           case MODIFY:
27173           case MOD:
27174           case MODE:
27175           case MONTH:
27176           case NATURAL:
27177           case NATURALN:
27178           case NEW:
27179           case NEXTVAL:
27180           case NO:
27181           case NOCOPY:
27182           case NONEDITIONABLE:
27183           case NOT:
27184           case NOWAIT:
27185           case NULL:
27186           case NULLIF:
27187           case NUMBER:
27188           case BFILE_BASE:
27189           case BLOB_BASE:
27190           case CLOB_BASE:
27191           case DATE_BASE:
27192           case NUMBER_BASE:
27193           case OBJECT:
27194           case OCIROWID:
27195           case OF:
27196           case OID:
27197           case ON:
27198           case OPAQUE:
27199           case OPEN:
27200           case OPERATOR:
27201           case OPTION:
27202           case OR:
27203           case ORDER:
27204           case ORGANIZATION:
27205           case OTHERS:
27206           case OUT:
27207           case OVERRIDING:
27208           case PACKAGE:
27209           case PARTITION:
27210           case PCTFREE:
27211           case PLS_INTEGER:
27212           case POSITIVE:
27213           case POSITIVEN:
27214           case PRESERVE:
27215           case PRIOR:
27216           case PROMPT:
27217           case PRIVATE:
27218           case PROCEDURE:
27219           case PUBLIC:
27220           case RAISE:
27221           case RANGE:
27222           case RAW:
27223           case REAL:
27224           case RECORD:
27225           case REF:
27226           case RELEASE:
27227           case RELIES_ON:
27228           case RENAME:
27229           case RESULT:
27230           case RETURN:
27231           case RETURNING:
27232           case REVERSE:
27233           case ROLLBACK:
27234           case ROW:
27235           case ROWS:
27236           case ROWID:
27237           case ROWNUM:
27238           case ROWTYPE:
27239           case SAVE:
27240           case SAVEPOINT:
27241           case SECOND:
27242           case SELECT:
27243           case SELF:
27244           case SEPARATE:
27245           case SET:
27246           case SHARE:
27247           case SMALLINT:
27248           case SPACE:
27249           case SQL:
27250           case SQLCODE:
27251           case SQLERRM:
27252           case START:
27253           case STATIC:
27254           case STDDEV:
27255           case SUBTYPE:
27256           case SUBSTITUTABLE:
27257           case SUCCESSFUL:
27258           case SUM:
27259           case SYNONYM:
27260           case SYSDATE:
27261           case SYS_REFCURSOR:
27262           case TABLE:
27263           case TEMPORARY:
27264           case THEN:
27265           case TIME:
27266           case TIMESTAMP:
27267           case TIMEZONE_REGION:
27268           case TIMEZONE_ABBR:
27269           case TIMEZONE_MINUTE:
27270           case TIMEZONE_HOUR:
27271           case TO:
27272           case TRANSACTION:
27273           case TRIGGER:
27274           case TRUE:
27275           case TYPE:
27276           case UI:
27277           case UNDER:
27278           case USING:
27279           case WHILE:
27280           case YES:
27281           case SHOW:
27282           case A:
27283           case UPDATE:
27284           case VARCHAR:
27285           case VARCHAR2:
27286           case DOUBLE:
27287           case DEC:
27288           case PRECISION:
27289           case INT:
27290           case NUMERIC:
27291           case SIGNTYPE:
27292           case NCHAR:
27293           case NVARCHAR2:
27294           case STRING:
27295           case UROWID:
27296           case VARRAY:
27297           case VARYING:
27298           case BFILE:
27299           case BLOB:
27300           case CLOB:
27301           case NCLOB:
27302           case YEAR:
27303           case LOCAL:
27304           case WITH:
27305           case ZONE:
27306           case CHARACTER:
27307           case AFTER:
27308           case BEFORE:
27309           case OLD:
27310           case PARENT:
27311           case ANALYZE:
27312           case ASSOCIATE:
27313           case AUDIT:
27314           case COMPOUND:
27315           case DATABASE:
27316           case CALL:
27317           case DDL:
27318           case DISASSOCIATE:
27319           case EACH:
27320           case FOLLOWS:
27321           case LOGOFF:
27322           case LOGON:
27323           case NESTED:
27324           case NOAUDIT:
27325           case SCHEMA:
27326           case SERVERERROR:
27327           case SHUTDOWN:
27328           case STARTUP:
27329           case STATEMENT:
27330           case STATISTICS:
27331           case SUSPEND:
27332           case TRUNCATE:
27333           case WRAPPED:
27334           case LIBRARY:
27335           case NAME:
27336           case STRUCT:
27337           case CONTEXT:
27338           case PARAMETERS:
27339           case LENGTH:
27340           case TDO:
27341           case MAXLEN:
27342           case CHARSETID:
27343           case CHARSETFORM:
27344           case ACCEPT:
27345           case ACCESSIBLE:
27346           case COPY:
27347           case DEFINE:
27348           case DISCONNECT:
27349           case HOST:
27350           case PRINT:
27351           case QUIT:
27352           case REMARK:
27353           case UNDEFINE:
27354           case VARIABLE:
27355           case WHENEVER:
27356           case ATTACH:
27357           case CAST:
27358           case TREAT:
27359           case TRIM:
27360           case LEFT:
27361           case RIGHT:
27362           case BOTH:
27363           case EMPTY:
27364           case MULTISET:
27365           case SUBMULTISET:
27366           case LEADING:
27367           case TRAILING:
27368           case CHAR_CS:
27369           case NCHAR_CS:
27370           case DBTIMEZONE:
27371           case SESSIONTIMEZONE:
27372           case AUTHENTICATED:
27373           case LINK:
27374           case SHARED:
27375           case DIRECTORY:
27376           case USER:
27377           case IDENTIFIER:
27378           case QUOTED_LITERAL:
27379           case SQLDATA_CLASS:
27380           case CUSTOMDATUM_CLASS:
27381           case ORADATA_CLASS:
27382           case JAVA_INTERFACE_CLASS:
27383             ID();
27384             break;
27385           case STRING_LITERAL:
27386             StringLiteral();
27387             break;
27388           default:
27389             jj_la1[403] = jj_gen;
27390             jj_consume_token(-1);
27391             throw new ParseException();
27392           }
27393           switch (jj_nt.kind) {
27394           case 6:
27395             ;
27396             break;
27397           default:
27398             jj_la1[404] = jj_gen;
27399             break label_94;
27400           }
27401         }
27402         jj_consume_token(7);
27403         break;
27404       case EXCEPTION_INIT:
27405         jj_consume_token(EXCEPTION_INIT);
27406         jj_consume_token(5);
27407         jj_consume_token(IDENTIFIER);
27408         jj_consume_token(6);
27409         switch (jj_nt.kind) {
27410         case 16:
27411         case 17:
27412           switch (jj_nt.kind) {
27413           case 16:
27414             jj_consume_token(16);
27415             break;
27416           case 17:
27417             jj_consume_token(17);
27418             break;
27419           default:
27420             jj_la1[405] = jj_gen;
27421             jj_consume_token(-1);
27422             throw new ParseException();
27423           }
27424           break;
27425         default:
27426           jj_la1[406] = jj_gen;
27427           ;
27428         }
27429         NumericLiteral();
27430         jj_consume_token(7);
27431         break;
27432       case INTERFACE:
27433         jj_consume_token(INTERFACE);
27434         jj_consume_token(5);
27435         jj_consume_token(IDENTIFIER);
27436         jj_consume_token(6);
27437         jj_consume_token(IDENTIFIER);
27438         jj_consume_token(6);
27439         NumericLiteral();
27440         jj_consume_token(7);
27441         break;
27442       default:
27443         jj_la1[407] = jj_gen;
27444         jj_consume_token(-1);
27445         throw new ParseException();
27446       }
27447         jjtree.closeNodeScope(jjtn000, true);
27448         jjtc000 = false;
27449         {if (true) return jjtn000 ;}
27450     } catch (Throwable jjte000) {
27451           if (jjtc000) {
27452             jjtree.clearNodeScope(jjtn000);
27453             jjtc000 = false;
27454           } else {
27455             jjtree.popNode();
27456           }
27457           if (jjte000 instanceof RuntimeException) {
27458             {if (true) throw (RuntimeException)jjte000;}
27459           }
27460           if (jjte000 instanceof ParseException) {
27461             {if (true) throw (ParseException)jjte000;}
27462           }
27463           {if (true) throw (Error)jjte000;}
27464     } finally {
27465           if (jjtc000) {
27466             jjtree.closeNodeScope(jjtn000, true);
27467           }
27468     }
27469     throw new Error("Missing return statement in function");
27470   }
27471 
27472 /** 
27473  * Trigger
27474  * Triggers are always outside of a package.
27475  *
27476  *  2006-05-17 - Matthias Hendler - added 
27477  */
27478 
27479 /*
27480   11g Trigger Syntax 
27481 
27482  create_trigger : 
27483  CREATE [OR REPLACE] TRIGGER [schema.]trigger 
27484 ( simple_dml_trigger | compound_dml_trigger | non_dml_trigger )
27485 [ FOLLOWS ( [schema.]trigger) ( , [schema.]trigger)*  ]
27486 [ ENABLE  | DISABLE ]
27487 ( WHEN ( trigger_condition ) 
27488 trigger_body
27489 
27490 
27491 simple_dml_trigger :
27492 (BEFORE |AFTER | INSTEAD OF)
27493 dml_event_clause 
27494 [ referencing_clause ]
27495 [ FOR EACH ROW ]
27496 
27497 
27498 
27499 compound_dml_trigger :
27500 FOR dml_event_clause 
27501 [ referencing_clause ]
27502 
27503 
27504 non_dml_trigger :
27505 (BEFORE> |<AFTER> ) 
27506 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
27507 ON
27508 (DATABASE | [schema.]SCHEMA
27509 
27510 
27511 
27512 trigger_body :
27513 (plsql_block | compound_trigger_block | CALL routine_clause)
27514 
27515 
27516 
27517 dml_event_clause:
27518 ( DELETE | INSERT | UPDATE [ OF column (, column ) ] )
27519 ON ( (schema.table | NESTED TABLE nested_table_column OF [schema.]view )
27520 
27521 referencing_clause:
27522 REFERENCING 
27523 (OLD AS old_alias | NEW AS new_alias | PARENT AS parent_alias )*  
27524 
27525 
27526 compound_trigger_block :
27527 COMPOUND TRIGGER 
27528 declare_section 
27529 (timing_point_section)+  
27530 END [trigger_name] ;
27531 
27532 timing_point_section:
27533 (
27534 BEFORE STATEMENT IS tps_body END BEFORE STATEMENT 
27535 |BEFORE EACH ROW IS tps_body END BEFORE EACH ROW 
27536 |AFTER STATEMENT IS tps_body END AFTER STATEMENT 
27537 |AFTER EACH ROW IS tps_body END AFTER EACH ROW 
27538 )
27539 
27540 
27541 tps_body:
27542 (statement)+
27543 (EXCEPTION exception_handler )*
27544 
27545 */
27546   final public ASTTriggerUnit TriggerUnit() throws ParseException {
27547  /*@bgen(jjtree) TriggerUnit */
27548  ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
27549  boolean jjtc000 = true;
27550  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
27551     try {
27552       switch (jj_nt.kind) {
27553       case CREATE:
27554         jj_consume_token(CREATE);
27555         switch (jj_nt.kind) {
27556         case OR:
27557           jj_consume_token(OR);
27558           jj_consume_token(REPLACE);
27559           break;
27560         default:
27561           jj_la1[408] = jj_gen;
27562           ;
27563         }
27564         switch (jj_nt.kind) {
27565         case EDITIONABLE:
27566         case NONEDITIONABLE:
27567           switch (jj_nt.kind) {
27568           case EDITIONABLE:
27569             jj_consume_token(EDITIONABLE);
27570             break;
27571           case NONEDITIONABLE:
27572             jj_consume_token(NONEDITIONABLE);
27573             break;
27574           default:
27575             jj_la1[409] = jj_gen;
27576             jj_consume_token(-1);
27577             throw new ParseException();
27578           }
27579           break;
27580         default:
27581           jj_la1[410] = jj_gen;
27582           ;
27583         }
27584         break;
27585       default:
27586         jj_la1[411] = jj_gen;
27587         ;
27588       }
27589       jj_consume_token(TRIGGER);
27590       simpleNode = ObjectNameDeclaration();
27591       switch (jj_nt.kind) {
27592       case BEFORE:
27593         jj_consume_token(BEFORE);
27594         break;
27595       case AFTER:
27596         jj_consume_token(AFTER);
27597         break;
27598       case INSTEADOF:
27599         jj_consume_token(INSTEADOF);
27600         break;
27601       case FOR:
27602         jj_consume_token(FOR);
27603         break;
27604       default:
27605         jj_la1[412] = jj_gen;
27606         jj_consume_token(-1);
27607         throw new ParseException();
27608       }
27609       switch (jj_nt.kind) {
27610       case DELETE:
27611       case INSERT:
27612       case UPDATE:
27613         switch (jj_nt.kind) {
27614         case DELETE:
27615           jj_consume_token(DELETE);
27616           break;
27617         case INSERT:
27618           jj_consume_token(INSERT);
27619           break;
27620         case UPDATE:
27621           jj_consume_token(UPDATE);
27622           break;
27623         default:
27624           jj_la1[413] = jj_gen;
27625           jj_consume_token(-1);
27626           throw new ParseException();
27627         }
27628         if (jj_2_74(6)) {
27629           jj_consume_token(OF);
27630           ID();
27631           label_95:
27632           while (true) {
27633             switch (jj_nt.kind) {
27634             case 6:
27635               ;
27636               break;
27637             default:
27638               jj_la1[414] = jj_gen;
27639               break label_95;
27640             }
27641             jj_consume_token(6);
27642             ID();
27643           }
27644         } else {
27645           ;
27646         }
27647         break;
27648       case ALTER:
27649       case COMMENT:
27650       case CREATE:
27651       case DROP:
27652       case GRANT:
27653       case RENAME:
27654       case REVOKE:
27655       case ANALYZE:
27656       case ASSOCIATE:
27657       case AUDIT:
27658       case DDL:
27659       case DISASSOCIATE:
27660       case LOGOFF:
27661       case LOGON:
27662       case NOAUDIT:
27663       case SERVERERROR:
27664       case SHUTDOWN:
27665       case STARTUP:
27666       case SUSPEND:
27667       case TRUNCATE:
27668         NonDMLEvent();
27669         break;
27670       default:
27671         jj_la1[415] = jj_gen;
27672         jj_consume_token(-1);
27673         throw new ParseException();
27674       }
27675       label_96:
27676       while (true) {
27677         switch (jj_nt.kind) {
27678         case OR:
27679           ;
27680           break;
27681         default:
27682           jj_la1[416] = jj_gen;
27683           break label_96;
27684         }
27685         jj_consume_token(OR);
27686         switch (jj_nt.kind) {
27687         case DELETE:
27688         case INSERT:
27689         case UPDATE:
27690           switch (jj_nt.kind) {
27691           case DELETE:
27692             jj_consume_token(DELETE);
27693             break;
27694           case INSERT:
27695             jj_consume_token(INSERT);
27696             break;
27697           case UPDATE:
27698             jj_consume_token(UPDATE);
27699             break;
27700           default:
27701             jj_la1[417] = jj_gen;
27702             jj_consume_token(-1);
27703             throw new ParseException();
27704           }
27705           if (jj_2_75(6)) {
27706             jj_consume_token(OF);
27707             ID();
27708             label_97:
27709             while (true) {
27710               switch (jj_nt.kind) {
27711               case 6:
27712                 ;
27713                 break;
27714               default:
27715                 jj_la1[418] = jj_gen;
27716                 break label_97;
27717               }
27718               jj_consume_token(6);
27719               ID();
27720             }
27721           } else {
27722             ;
27723           }
27724           break;
27725         case ALTER:
27726         case COMMENT:
27727         case CREATE:
27728         case DROP:
27729         case GRANT:
27730         case RENAME:
27731         case REVOKE:
27732         case ANALYZE:
27733         case ASSOCIATE:
27734         case AUDIT:
27735         case DDL:
27736         case DISASSOCIATE:
27737         case LOGOFF:
27738         case LOGON:
27739         case NOAUDIT:
27740         case SERVERERROR:
27741         case SHUTDOWN:
27742         case STARTUP:
27743         case SUSPEND:
27744         case TRUNCATE:
27745           NonDMLEvent();
27746           break;
27747         default:
27748           jj_la1[419] = jj_gen;
27749           jj_consume_token(-1);
27750           throw new ParseException();
27751         }
27752       }
27753       jj_consume_token(ON);
27754       switch (jj_nt.kind) {
27755       case DATABASE:
27756         jj_consume_token(DATABASE);
27757         break;
27758       default:
27759         jj_la1[420] = jj_gen;
27760         if (jj_2_78(2)) {
27761           jj_consume_token(NESTED);
27762           jj_consume_token(TABLE);
27763           ID();
27764           jj_consume_token(OF);
27765           if (jj_2_76(2)) {
27766             ID();
27767             jj_consume_token(3);
27768           } else {
27769             ;
27770           }
27771           ID();
27772         } else {
27773           switch (jj_nt.kind) {
27774           case REPLACE:
27775           case DEFINER:
27776           case CURRENT_USER:
27777           case SERIALLY_REUSABLE:
27778           case RESTRICT_REFERENCES:
27779           case EXCEPTION_INIT:
27780           case AUTONOMOUS_TRANSACTION:
27781           case LANGUAGE:
27782           case INLINE:
27783           case ADD:
27784           case AGGREGATE:
27785           case ALL:
27786           case ALTER:
27787           case AND:
27788           case ANY:
27789           case ARRAY:
27790           case AS:
27791           case ASC:
27792           case AT:
27793           case ATTRIBUTE:
27794           case AUTHID:
27795           case AVG:
27796           case BETWEEN:
27797           case BINARY_INTEGER:
27798           case BODY:
27799           case BOOLEAN:
27800           case BULK:
27801           case BY:
27802           case BYTE:
27803           case CASCADE:
27804           case CASE:
27805           case CHAR:
27806           case CHAR_BASE:
27807           case CHECK:
27808           case CLOSE:
27809           case CLUSTER:
27810           case COALESCE:
27811           case COLLECT:
27812           case COLUMN:
27813           case COMMENT:
27814           case COMMIT:
27815           case COMPRESS:
27816           case CONNECT:
27817           case CONSTANT:
27818           case CONSTRUCTOR:
27819           case CONTINUE:
27820           case CONVERT:
27821           case CREATE:
27822           case CURRENT:
27823           case CURRVAL:
27824           case CURSOR:
27825           case DATA:
27826           case DATE:
27827           case DAY:
27828           case DECLARE:
27829           case DECIMAL:
27830           case _DEFAULT:
27831           case DELETE:
27832           case DESC:
27833           case DISABLE:
27834           case DISTINCT:
27835           case DO:
27836           case DROP:
27837           case EDITIONABLE:
27838           case ELEMENT:
27839           case ELSE:
27840           case ELSIF:
27841           case ENABLE:
27842           case ESCAPE:
27843           case EXCEPT:
27844           case EXCEPTION:
27845           case EXCEPTIONS:
27846           case EXCLUSIVE:
27847           case EXECUTE:
27848           case EXISTS:
27849           case EXIT:
27850           case EXTERNAL:
27851           case EXTENDS:
27852           case EXTRACT:
27853           case FALSE:
27854           case FETCH:
27855           case FINAL:
27856           case FLOAT:
27857           case FOR:
27858           case FORALL:
27859           case FORCE:
27860           case FROM:
27861           case FUNCTION:
27862           case GLOBAL:
27863           case GOTO:
27864           case GROUP:
27865           case HASH:
27866           case HAVING:
27867           case HEAP:
27868           case HOUR:
27869           case IF:
27870           case IMMEDIATE:
27871           case IN:
27872           case INDEX:
27873           case INDICES:
27874           case INDEXTYPE:
27875           case INDICATOR:
27876           case INSERT:
27877           case INSTANTIABLE:
27878           case INTEGER:
27879           case INTERFACE:
27880           case INTERSECT:
27881           case INTERVAL:
27882           case INTO:
27883           case INVALIDATE:
27884           case IS:
27885           case ISOLATION:
27886           case JAVA:
27887           case LEVEL:
27888           case LIKE:
27889           case LIMIT:
27890           case LIMITED:
27891           case LOCK:
27892           case LONG:
27893           case LOOP:
27894           case MAP:
27895           case MAX:
27896           case MEMBER:
27897           case MERGE:
27898           case MIN:
27899           case MINUS:
27900           case MINUTE:
27901           case MLSLABEL:
27902           case MODIFY:
27903           case MOD:
27904           case MODE:
27905           case MONTH:
27906           case NATURAL:
27907           case NATURALN:
27908           case NEW:
27909           case NEXTVAL:
27910           case NO:
27911           case NOCOPY:
27912           case NONEDITIONABLE:
27913           case NOT:
27914           case NOWAIT:
27915           case NULL:
27916           case NULLIF:
27917           case NUMBER:
27918           case BFILE_BASE:
27919           case BLOB_BASE:
27920           case CLOB_BASE:
27921           case DATE_BASE:
27922           case NUMBER_BASE:
27923           case OBJECT:
27924           case OCIROWID:
27925           case OF:
27926           case OID:
27927           case ON:
27928           case OPAQUE:
27929           case OPEN:
27930           case OPERATOR:
27931           case OPTION:
27932           case OR:
27933           case ORDER:
27934           case ORGANIZATION:
27935           case OTHERS:
27936           case OUT:
27937           case OVERRIDING:
27938           case PACKAGE:
27939           case PARTITION:
27940           case PCTFREE:
27941           case PLS_INTEGER:
27942           case POSITIVE:
27943           case POSITIVEN:
27944           case PRESERVE:
27945           case PRIOR:
27946           case PROMPT:
27947           case PRIVATE:
27948           case PROCEDURE:
27949           case PUBLIC:
27950           case RAISE:
27951           case RANGE:
27952           case RAW:
27953           case REAL:
27954           case RECORD:
27955           case REF:
27956           case RELEASE:
27957           case RELIES_ON:
27958           case RENAME:
27959           case RESULT:
27960           case RETURN:
27961           case RETURNING:
27962           case REVERSE:
27963           case ROLLBACK:
27964           case ROW:
27965           case ROWS:
27966           case ROWID:
27967           case ROWNUM:
27968           case ROWTYPE:
27969           case SAVE:
27970           case SAVEPOINT:
27971           case SECOND:
27972           case SELECT:
27973           case SELF:
27974           case SEPARATE:
27975           case SET:
27976           case SHARE:
27977           case SMALLINT:
27978           case SPACE:
27979           case SQL:
27980           case SQLCODE:
27981           case SQLERRM:
27982           case START:
27983           case STATIC:
27984           case STDDEV:
27985           case SUBTYPE:
27986           case SUBSTITUTABLE:
27987           case SUCCESSFUL:
27988           case SUM:
27989           case SYNONYM:
27990           case SYSDATE:
27991           case SYS_REFCURSOR:
27992           case TABLE:
27993           case TEMPORARY:
27994           case THEN:
27995           case TIME:
27996           case TIMESTAMP:
27997           case TIMEZONE_REGION:
27998           case TIMEZONE_ABBR:
27999           case TIMEZONE_MINUTE:
28000           case TIMEZONE_HOUR:
28001           case TO:
28002           case TRANSACTION:
28003           case TRIGGER:
28004           case TRUE:
28005           case TYPE:
28006           case UI:
28007           case UNDER:
28008           case USING:
28009           case WHILE:
28010           case YES:
28011           case SHOW:
28012           case A:
28013           case UPDATE:
28014           case VARCHAR:
28015           case VARCHAR2:
28016           case DOUBLE:
28017           case DEC:
28018           case PRECISION:
28019           case INT:
28020           case NUMERIC:
28021           case SIGNTYPE:
28022           case NCHAR:
28023           case NVARCHAR2:
28024           case STRING:
28025           case UROWID:
28026           case VARRAY:
28027           case VARYING:
28028           case BFILE:
28029           case BLOB:
28030           case CLOB:
28031           case NCLOB:
28032           case YEAR:
28033           case LOCAL:
28034           case WITH:
28035           case ZONE:
28036           case CHARACTER:
28037           case AFTER:
28038           case BEFORE:
28039           case OLD:
28040           case PARENT:
28041           case ANALYZE:
28042           case ASSOCIATE:
28043           case AUDIT:
28044           case COMPOUND:
28045           case DATABASE:
28046           case CALL:
28047           case DDL:
28048           case DISASSOCIATE:
28049           case EACH:
28050           case FOLLOWS:
28051           case LOGOFF:
28052           case LOGON:
28053           case NESTED:
28054           case NOAUDIT:
28055           case SCHEMA:
28056           case SERVERERROR:
28057           case SHUTDOWN:
28058           case STARTUP:
28059           case STATEMENT:
28060           case STATISTICS:
28061           case SUSPEND:
28062           case TRUNCATE:
28063           case WRAPPED:
28064           case LIBRARY:
28065           case NAME:
28066           case STRUCT:
28067           case CONTEXT:
28068           case PARAMETERS:
28069           case LENGTH:
28070           case TDO:
28071           case MAXLEN:
28072           case CHARSETID:
28073           case CHARSETFORM:
28074           case ACCEPT:
28075           case ACCESSIBLE:
28076           case COPY:
28077           case DEFINE:
28078           case DISCONNECT:
28079           case HOST:
28080           case PRINT:
28081           case QUIT:
28082           case REMARK:
28083           case UNDEFINE:
28084           case VARIABLE:
28085           case WHENEVER:
28086           case ATTACH:
28087           case CAST:
28088           case TREAT:
28089           case TRIM:
28090           case LEFT:
28091           case RIGHT:
28092           case BOTH:
28093           case EMPTY:
28094           case MULTISET:
28095           case SUBMULTISET:
28096           case LEADING:
28097           case TRAILING:
28098           case CHAR_CS:
28099           case NCHAR_CS:
28100           case DBTIMEZONE:
28101           case SESSIONTIMEZONE:
28102           case AUTHENTICATED:
28103           case LINK:
28104           case SHARED:
28105           case DIRECTORY:
28106           case USER:
28107           case IDENTIFIER:
28108           case QUOTED_LITERAL:
28109           case SQLDATA_CLASS:
28110           case CUSTOMDATUM_CLASS:
28111           case ORADATA_CLASS:
28112           case JAVA_INTERFACE_CLASS:
28113             if (jj_2_77(2)) {
28114               ID();
28115               jj_consume_token(3);
28116             } else {
28117               ;
28118             }
28119             ID();
28120             break;
28121           default:
28122             jj_la1[421] = jj_gen;
28123             jj_consume_token(-1);
28124             throw new ParseException();
28125           }
28126         }
28127       }
28128       switch (jj_nt.kind) {
28129       case REFERENCING:
28130         jj_consume_token(REFERENCING);
28131         label_98:
28132         while (true) {
28133           switch (jj_nt.kind) {
28134           case NEW:
28135           case OLD:
28136           case PARENT:
28137             ;
28138             break;
28139           default:
28140             jj_la1[422] = jj_gen;
28141             break label_98;
28142           }
28143           switch (jj_nt.kind) {
28144           case OLD:
28145             jj_consume_token(OLD);
28146             break;
28147           case NEW:
28148             jj_consume_token(NEW);
28149             break;
28150           case PARENT:
28151             jj_consume_token(PARENT);
28152             break;
28153           default:
28154             jj_la1[423] = jj_gen;
28155             jj_consume_token(-1);
28156             throw new ParseException();
28157           }
28158           jj_consume_token(AS);
28159           ID();
28160         }
28161         break;
28162       default:
28163         jj_la1[424] = jj_gen;
28164         ;
28165       }
28166       switch (jj_nt.kind) {
28167       case FOREACHROW:
28168         jj_consume_token(FOREACHROW);
28169         break;
28170       default:
28171         jj_la1[425] = jj_gen;
28172         ;
28173       }
28174       switch (jj_nt.kind) {
28175       case REVERSE:
28176       case FORWARD:
28177       case CROSSEDITION:
28178         switch (jj_nt.kind) {
28179         case REVERSE:
28180         case FORWARD:
28181           switch (jj_nt.kind) {
28182           case FORWARD:
28183             jj_consume_token(FORWARD);
28184             break;
28185           case REVERSE:
28186             jj_consume_token(REVERSE);
28187             break;
28188           default:
28189             jj_la1[426] = jj_gen;
28190             jj_consume_token(-1);
28191             throw new ParseException();
28192           }
28193           break;
28194         default:
28195           jj_la1[427] = jj_gen;
28196           ;
28197         }
28198         jj_consume_token(CROSSEDITION);
28199         break;
28200       default:
28201         jj_la1[428] = jj_gen;
28202         ;
28203       }
28204       switch (jj_nt.kind) {
28205       case FOLLOWS:
28206       case PRECEDES:
28207         switch (jj_nt.kind) {
28208         case FOLLOWS:
28209           jj_consume_token(FOLLOWS);
28210           break;
28211         case PRECEDES:
28212           jj_consume_token(PRECEDES);
28213           break;
28214         default:
28215           jj_la1[429] = jj_gen;
28216           jj_consume_token(-1);
28217           throw new ParseException();
28218         }
28219         if (jj_2_79(2)) {
28220           ID();
28221           jj_consume_token(3);
28222         } else {
28223           ;
28224         }
28225         ID();
28226         label_99:
28227         while (true) {
28228           switch (jj_nt.kind) {
28229           case 6:
28230             ;
28231             break;
28232           default:
28233             jj_la1[430] = jj_gen;
28234             break label_99;
28235           }
28236           jj_consume_token(6);
28237           if (jj_2_80(2)) {
28238             ID();
28239             jj_consume_token(3);
28240           } else {
28241             ;
28242           }
28243           ID();
28244         }
28245         break;
28246       default:
28247         jj_la1[431] = jj_gen;
28248         ;
28249       }
28250       switch (jj_nt.kind) {
28251       case DISABLE:
28252       case ENABLE:
28253         switch (jj_nt.kind) {
28254         case ENABLE:
28255           jj_consume_token(ENABLE);
28256           break;
28257         case DISABLE:
28258           jj_consume_token(DISABLE);
28259           break;
28260         default:
28261           jj_la1[432] = jj_gen;
28262           jj_consume_token(-1);
28263           throw new ParseException();
28264         }
28265         break;
28266       default:
28267         jj_la1[433] = jj_gen;
28268         ;
28269       }
28270       switch (jj_nt.kind) {
28271       case WHEN:
28272         jj_consume_token(WHEN);
28273         jj_consume_token(5);
28274         ConditionalOrExpression();
28275         jj_consume_token(7);
28276         break;
28277       default:
28278         jj_la1[434] = jj_gen;
28279         ;
28280       }
28281       switch (jj_nt.kind) {
28282       case CALL:
28283         jj_consume_token(CALL);
28284         PrimaryExpression();
28285         jj_consume_token(4);
28286         break;
28287       case COMPOUND:
28288         CompoundTriggerBlock();
28289         break;
28290       case BEGIN:
28291       case DECLARE:
28292         Block();
28293         jj_consume_token(4);
28294         break;
28295       default:
28296         jj_la1[435] = jj_gen;
28297         jj_consume_token(-1);
28298         throw new ParseException();
28299       }
28300         jjtree.closeNodeScope(jjtn000, true);
28301         jjtc000 = false;
28302         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
28303     } catch (Throwable jjte000) {
28304           if (jjtc000) {
28305             jjtree.clearNodeScope(jjtn000);
28306             jjtc000 = false;
28307           } else {
28308             jjtree.popNode();
28309           }
28310           if (jjte000 instanceof RuntimeException) {
28311             {if (true) throw (RuntimeException)jjte000;}
28312           }
28313           if (jjte000 instanceof ParseException) {
28314             {if (true) throw (ParseException)jjte000;}
28315           }
28316           {if (true) throw (Error)jjte000;}
28317     } finally {
28318           if (jjtc000) {
28319             jjtree.closeNodeScope(jjtn000, true);
28320           }
28321     }
28322     throw new Error("Missing return statement in function");
28323   }
28324 
28325   final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
28326  /*@bgen(jjtree) TriggerTimingPointSection */
28327  ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
28328  boolean jjtc000 = true;
28329  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
28330     try {
28331       switch (jj_nt.kind) {
28332       case BEFORE:
28333         jj_consume_token(BEFORE);
28334         break;
28335       case AFTER:
28336         jj_consume_token(AFTER);
28337         break;
28338       case INSTEADOF:
28339         jj_consume_token(INSTEADOF);
28340         break;
28341       default:
28342         jj_la1[436] = jj_gen;
28343         jj_consume_token(-1);
28344         throw new ParseException();
28345       }
28346                                         sb.append(token.image) ;
28347       switch (jj_nt.kind) {
28348       case STATEMENT:
28349         jj_consume_token(STATEMENT);
28350         break;
28351       case EACH:
28352         jj_consume_token(EACH);
28353         jj_consume_token(ROW);
28354         break;
28355       default:
28356         jj_la1[437] = jj_gen;
28357         jj_consume_token(-1);
28358         throw new ParseException();
28359       }
28360                                      sb.append(" "); sb.append(token.image) ;
28361       jj_consume_token(IS);
28362       jj_consume_token(BEGIN);
28363       label_100:
28364       while (true) {
28365         Statement();
28366         switch (jj_nt.kind) {
28367         case 5:
28368         case 16:
28369         case 17:
28370         case 21:
28371         case REPLACE:
28372         case DEFINER:
28373         case CURRENT_USER:
28374         case LANGUAGE:
28375         case INLINE:
28376         case ADD:
28377         case AGGREGATE:
28378         case ARRAY:
28379         case AT:
28380         case ATTRIBUTE:
28381         case AUTHID:
28382         case BEGIN:
28383         case BODY:
28384         case BULK:
28385         case BYTE:
28386         case CASCADE:
28387         case CASE:
28388         case CLOSE:
28389         case COALESCE:
28390         case COLLECT:
28391         case COLUMN:
28392         case COMMENT:
28393         case COMMIT:
28394         case CONSTRUCTOR:
28395         case CONTINUE:
28396         case CONVERT:
28397         case CURRENT:
28398         case CURSOR:
28399         case DATA:
28400         case DATE:
28401         case DAY:
28402         case DECLARE:
28403         case DELETE:
28404         case DISABLE:
28405         case EDITIONABLE:
28406         case ELEMENT:
28407         case ENABLE:
28408         case ESCAPE:
28409         case EXCEPT:
28410         case EXCEPTIONS:
28411         case EXECUTE:
28412         case EXIT:
28413         case EXTERNAL:
28414         case EXTENDS:
28415         case EXTRACT:
28416         case FALSE:
28417         case FETCH:
28418         case FINAL:
28419         case FOR:
28420         case FORALL:
28421         case FORCE:
28422         case FUNCTION:
28423         case GLOBAL:
28424         case GOTO:
28425         case HASH:
28426         case HEAP:
28427         case HOUR:
28428         case IF:
28429         case IMMEDIATE:
28430         case INDICES:
28431         case INDEXTYPE:
28432         case INDICATOR:
28433         case INSERT:
28434         case INSTANTIABLE:
28435         case INTERVAL:
28436         case INVALIDATE:
28437         case ISOLATION:
28438         case JAVA:
28439         case LEVEL:
28440         case LIMIT:
28441         case LOCK:
28442         case LOOP:
28443         case MAP:
28444         case MAX:
28445         case MEMBER:
28446         case MERGE:
28447         case MIN:
28448         case MINUTE:
28449         case MLSLABEL:
28450         case MODIFY:
28451         case MOD:
28452         case MONTH:
28453         case NATURAL:
28454         case NEW:
28455         case NEW_DOT:
28456         case NO:
28457         case NONEDITIONABLE:
28458         case NOT:
28459         case NULL:
28460         case NULLIF:
28461         case OBJECT:
28462         case OID:
28463         case OPAQUE:
28464         case OPEN:
28465         case OPERATOR:
28466         case ORGANIZATION:
28467         case OTHERS:
28468         case OVERRIDING:
28469         case PACKAGE:
28470         case PARTITION:
28471         case PIPE:
28472         case PRAGMA:
28473         case PRESERVE:
28474         case PRIVATE:
28475         case PROCEDURE:
28476         case RAISE:
28477         case RANGE:
28478         case RAW:
28479         case REAL:
28480         case RECORD:
28481         case REF:
28482         case RELEASE:
28483         case RELIES_ON:
28484         case RENAME:
28485         case RESULT:
28486         case RETURN:
28487         case RETURNING:
28488         case REVERSE:
28489         case ROLLBACK:
28490         case ROW:
28491         case ROWS:
28492         case ROWID:
28493         case ROWNUM:
28494         case SAVE:
28495         case SAVEPOINT:
28496         case SECOND:
28497         case SELECT:
28498         case SELF:
28499         case SET:
28500         case SPACE:
28501         case SQL:
28502         case SQLCODE:
28503         case SQLERRM:
28504         case STATIC:
28505         case SUBTYPE:
28506         case SUBSTITUTABLE:
28507         case SUCCESSFUL:
28508         case SYSDATE:
28509         case SYS_REFCURSOR:
28510         case TEMPORARY:
28511         case TIME:
28512         case TIMESTAMP:
28513         case TIMEZONE_REGION:
28514         case TIMEZONE_ABBR:
28515         case TIMEZONE_MINUTE:
28516         case TIMEZONE_HOUR:
28517         case TRANSACTION:
28518         case TRUE:
28519         case TYPE:
28520         case UNDER:
28521         case USING:
28522         case WHILE:
28523         case YES:
28524         case SHOW:
28525         case A:
28526         case UPDATE:
28527         case DOUBLE:
28528         case DEC:
28529         case PRECISION:
28530         case INT:
28531         case NUMERIC:
28532         case NCHAR:
28533         case NVARCHAR2:
28534         case STRING:
28535         case UROWID:
28536         case VARRAY:
28537         case VARYING:
28538         case BFILE:
28539         case BLOB:
28540         case CLOB:
28541         case NCLOB:
28542         case YEAR:
28543         case LOCAL:
28544         case WITH:
28545         case ZONE:
28546         case CHARACTER:
28547         case AFTER:
28548         case BEFORE:
28549         case OLD:
28550         case PARENT:
28551         case CC_IF:
28552         case CC_ERROR:
28553         case ANALYZE:
28554         case ASSOCIATE:
28555         case AUDIT:
28556         case COMPOUND:
28557         case DATABASE:
28558         case CALL:
28559         case DDL:
28560         case DISASSOCIATE:
28561         case EACH:
28562         case FOLLOWS:
28563         case LOGOFF:
28564         case LOGON:
28565         case NESTED:
28566         case NOAUDIT:
28567         case SCHEMA:
28568         case SERVERERROR:
28569         case SHUTDOWN:
28570         case STARTUP:
28571         case STATEMENT:
28572         case STATISTICS:
28573         case SUSPEND:
28574         case TRUNCATE:
28575         case WRAPPED:
28576         case LIBRARY:
28577         case NAME:
28578         case STRUCT:
28579         case CONTEXT:
28580         case PARAMETERS:
28581         case LENGTH:
28582         case TDO:
28583         case MAXLEN:
28584         case CHARSETID:
28585         case CHARSETFORM:
28586         case ACCEPT:
28587         case ACCESSIBLE:
28588         case COPY:
28589         case DEFINE:
28590         case DISCONNECT:
28591         case HOST:
28592         case PRINT:
28593         case QUIT:
28594         case REMARK:
28595         case UNDEFINE:
28596         case VARIABLE:
28597         case WHENEVER:
28598         case ATTACH:
28599         case CAST:
28600         case TREAT:
28601         case TRIM:
28602         case LEFT:
28603         case RIGHT:
28604         case BOTH:
28605         case EMPTY:
28606         case MULTISET:
28607         case SUBMULTISET:
28608         case LEADING:
28609         case TRAILING:
28610         case CHAR_CS:
28611         case NCHAR_CS:
28612         case DBTIMEZONE:
28613         case SESSIONTIMEZONE:
28614         case AUTHENTICATED:
28615         case LINK:
28616         case SHARED:
28617         case DIRECTORY:
28618         case USER:
28619         case IDENTIFIER:
28620         case UNSIGNED_NUMERIC_LITERAL:
28621         case CHARACTER_LITERAL:
28622         case STRING_LITERAL:
28623         case QUOTED_LITERAL:
28624           ;
28625           break;
28626         default:
28627           jj_la1[438] = jj_gen;
28628           break label_100;
28629         }
28630       }
28631       jj_consume_token(END);
28632       switch (jj_nt.kind) {
28633       case BEFORE:
28634         jj_consume_token(BEFORE);
28635         break;
28636       case AFTER:
28637         jj_consume_token(AFTER);
28638         break;
28639       case INSTEADOF:
28640         jj_consume_token(INSTEADOF);
28641         break;
28642       default:
28643         jj_la1[439] = jj_gen;
28644         jj_consume_token(-1);
28645         throw new ParseException();
28646       }
28647       switch (jj_nt.kind) {
28648       case STATEMENT:
28649         jj_consume_token(STATEMENT);
28650         break;
28651       case EACH:
28652         jj_consume_token(EACH);
28653         jj_consume_token(ROW);
28654         break;
28655       default:
28656         jj_la1[440] = jj_gen;
28657         jj_consume_token(-1);
28658         throw new ParseException();
28659       }
28660       jj_consume_token(4);
28661 
28662    jjtree.closeNodeScope(jjtn000, true);
28663    jjtc000 = false;
28664    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
28665     } catch (Throwable jjte000) {
28666    if (jjtc000) {
28667      jjtree.clearNodeScope(jjtn000);
28668      jjtc000 = false;
28669    } else {
28670      jjtree.popNode();
28671    }
28672    if (jjte000 instanceof RuntimeException) {
28673      {if (true) throw (RuntimeException)jjte000;}
28674    }
28675    if (jjte000 instanceof ParseException) {
28676      {if (true) throw (ParseException)jjte000;}
28677    }
28678    {if (true) throw (Error)jjte000;}
28679     } finally {
28680    if (jjtc000) {
28681      jjtree.closeNodeScope(jjtn000, true);
28682    }
28683     }
28684     throw new Error("Missing return statement in function");
28685   }
28686 
28687   final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
28688  /*@bgen(jjtree) CompoundTriggerBlock */
28689   ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
28690   boolean jjtc000 = true;
28691   jjtree.openNodeScope(jjtn000);
28692     try {
28693       jj_consume_token(COMPOUND);
28694       jj_consume_token(TRIGGER);
28695       label_101:
28696       while (true) {
28697         switch (jj_nt.kind) {
28698         case REPLACE:
28699         case DEFINER:
28700         case CURRENT_USER:
28701         case SERIALLY_REUSABLE:
28702         case RESTRICT_REFERENCES:
28703         case EXCEPTION_INIT:
28704         case AUTONOMOUS_TRANSACTION:
28705         case LANGUAGE:
28706         case INLINE:
28707         case ADD:
28708         case AGGREGATE:
28709         case ALL:
28710         case ALTER:
28711         case AND:
28712         case ANY:
28713         case ARRAY:
28714         case AS:
28715         case ASC:
28716         case AT:
28717         case ATTRIBUTE:
28718         case AUTHID:
28719         case AVG:
28720         case BETWEEN:
28721         case BINARY_INTEGER:
28722         case BODY:
28723         case BOOLEAN:
28724         case BULK:
28725         case BY:
28726         case BYTE:
28727         case CASCADE:
28728         case CASE:
28729         case CHAR:
28730         case CHAR_BASE:
28731         case CHECK:
28732         case CLOSE:
28733         case CLUSTER:
28734         case COALESCE:
28735         case COLLECT:
28736         case COLUMN:
28737         case COMMENT:
28738         case COMMIT:
28739         case COMPRESS:
28740         case CONNECT:
28741         case CONSTANT:
28742         case CONSTRUCTOR:
28743         case CONTINUE:
28744         case CONVERT:
28745         case CREATE:
28746         case CURRENT:
28747         case CURRVAL:
28748         case CURSOR:
28749         case DATA:
28750         case DATE:
28751         case DAY:
28752         case DECLARE:
28753         case DECIMAL:
28754         case _DEFAULT:
28755         case DELETE:
28756         case DESC:
28757         case DISABLE:
28758         case DISTINCT:
28759         case DO:
28760         case DROP:
28761         case EDITIONABLE:
28762         case ELEMENT:
28763         case ELSE:
28764         case ELSIF:
28765         case ENABLE:
28766         case ESCAPE:
28767         case EXCEPT:
28768         case EXCEPTION:
28769         case EXCEPTIONS:
28770         case EXCLUSIVE:
28771         case EXECUTE:
28772         case EXISTS:
28773         case EXIT:
28774         case EXTERNAL:
28775         case EXTENDS:
28776         case EXTRACT:
28777         case FALSE:
28778         case FETCH:
28779         case FINAL:
28780         case FLOAT:
28781         case FOR:
28782         case FORALL:
28783         case FORCE:
28784         case FROM:
28785         case FUNCTION:
28786         case GLOBAL:
28787         case GOTO:
28788         case GROUP:
28789         case HASH:
28790         case HAVING:
28791         case HEAP:
28792         case HOUR:
28793         case IF:
28794         case IMMEDIATE:
28795         case IN:
28796         case INDEX:
28797         case INDICES:
28798         case INDEXTYPE:
28799         case INDICATOR:
28800         case INSERT:
28801         case INSTANTIABLE:
28802         case INTEGER:
28803         case INTERFACE:
28804         case INTERSECT:
28805         case INTERVAL:
28806         case INTO:
28807         case INVALIDATE:
28808         case IS:
28809         case ISOLATION:
28810         case JAVA:
28811         case LEVEL:
28812         case LIKE:
28813         case LIMIT:
28814         case LIMITED:
28815         case LOCK:
28816         case LONG:
28817         case LOOP:
28818         case MAP:
28819         case MAX:
28820         case MEMBER:
28821         case MERGE:
28822         case MIN:
28823         case MINUS:
28824         case MINUTE:
28825         case MLSLABEL:
28826         case MODIFY:
28827         case MOD:
28828         case MODE:
28829         case MONTH:
28830         case NATURAL:
28831         case NATURALN:
28832         case NEW:
28833         case NEXTVAL:
28834         case NO:
28835         case NOCOPY:
28836         case NONEDITIONABLE:
28837         case NOT:
28838         case NOWAIT:
28839         case NULL:
28840         case NULLIF:
28841         case NUMBER:
28842         case BFILE_BASE:
28843         case BLOB_BASE:
28844         case CLOB_BASE:
28845         case DATE_BASE:
28846         case NUMBER_BASE:
28847         case OBJECT:
28848         case OCIROWID:
28849         case OF:
28850         case OID:
28851         case ON:
28852         case OPAQUE:
28853         case OPEN:
28854         case OPERATOR:
28855         case OPTION:
28856         case OR:
28857         case ORDER:
28858         case ORGANIZATION:
28859         case OTHERS:
28860         case OUT:
28861         case OVERRIDING:
28862         case PACKAGE:
28863         case PARTITION:
28864         case PCTFREE:
28865         case PLS_INTEGER:
28866         case POSITIVE:
28867         case POSITIVEN:
28868         case PRAGMA:
28869         case PRESERVE:
28870         case PRIOR:
28871         case PROMPT:
28872         case PRIVATE:
28873         case PROCEDURE:
28874         case PUBLIC:
28875         case RAISE:
28876         case RANGE:
28877         case RAW:
28878         case REAL:
28879         case RECORD:
28880         case REF:
28881         case RELEASE:
28882         case RELIES_ON:
28883         case RENAME:
28884         case RESULT:
28885         case RETURN:
28886         case RETURNING:
28887         case REVERSE:
28888         case ROLLBACK:
28889         case ROW:
28890         case ROWS:
28891         case ROWID:
28892         case ROWNUM:
28893         case ROWTYPE:
28894         case SAVE:
28895         case SAVEPOINT:
28896         case SECOND:
28897         case SELECT:
28898         case SELF:
28899         case SEPARATE:
28900         case SET:
28901         case SHARE:
28902         case SMALLINT:
28903         case SPACE:
28904         case SQL:
28905         case SQLCODE:
28906         case SQLERRM:
28907         case START:
28908         case STATIC:
28909         case STDDEV:
28910         case SUBTYPE:
28911         case SUBSTITUTABLE:
28912         case SUCCESSFUL:
28913         case SUM:
28914         case SYNONYM:
28915         case SYSDATE:
28916         case SYS_REFCURSOR:
28917         case TABLE:
28918         case TEMPORARY:
28919         case THEN:
28920         case TIME:
28921         case TIMESTAMP:
28922         case TIMEZONE_REGION:
28923         case TIMEZONE_ABBR:
28924         case TIMEZONE_MINUTE:
28925         case TIMEZONE_HOUR:
28926         case TO:
28927         case TRANSACTION:
28928         case TRIGGER:
28929         case TRUE:
28930         case TYPE:
28931         case UI:
28932         case UNDER:
28933         case USING:
28934         case WHILE:
28935         case YES:
28936         case SHOW:
28937         case A:
28938         case UPDATE:
28939         case VARCHAR:
28940         case VARCHAR2:
28941         case DOUBLE:
28942         case DEC:
28943         case PRECISION:
28944         case INT:
28945         case NUMERIC:
28946         case SIGNTYPE:
28947         case NCHAR:
28948         case NVARCHAR2:
28949         case STRING:
28950         case UROWID:
28951         case VARRAY:
28952         case VARYING:
28953         case BFILE:
28954         case BLOB:
28955         case CLOB:
28956         case NCLOB:
28957         case YEAR:
28958         case LOCAL:
28959         case WITH:
28960         case ZONE:
28961         case CHARACTER:
28962         case AFTER:
28963         case BEFORE:
28964         case INSTEADOF:
28965         case OLD:
28966         case PARENT:
28967         case ANALYZE:
28968         case ASSOCIATE:
28969         case AUDIT:
28970         case COMPOUND:
28971         case DATABASE:
28972         case CALL:
28973         case DDL:
28974         case DISASSOCIATE:
28975         case EACH:
28976         case FOLLOWS:
28977         case LOGOFF:
28978         case LOGON:
28979         case NESTED:
28980         case NOAUDIT:
28981         case SCHEMA:
28982         case SERVERERROR:
28983         case SHUTDOWN:
28984         case STARTUP:
28985         case STATEMENT:
28986         case STATISTICS:
28987         case SUSPEND:
28988         case TRUNCATE:
28989         case WRAPPED:
28990         case LIBRARY:
28991         case NAME:
28992         case STRUCT:
28993         case CONTEXT:
28994         case PARAMETERS:
28995         case LENGTH:
28996         case TDO:
28997         case MAXLEN:
28998         case CHARSETID:
28999         case CHARSETFORM:
29000         case ACCEPT:
29001         case ACCESSIBLE:
29002         case COPY:
29003         case DEFINE:
29004         case DISCONNECT:
29005         case HOST:
29006         case PRINT:
29007         case QUIT:
29008         case REMARK:
29009         case UNDEFINE:
29010         case VARIABLE:
29011         case WHENEVER:
29012         case ATTACH:
29013         case CAST:
29014         case TREAT:
29015         case TRIM:
29016         case LEFT:
29017         case RIGHT:
29018         case BOTH:
29019         case EMPTY:
29020         case MULTISET:
29021         case SUBMULTISET:
29022         case LEADING:
29023         case TRAILING:
29024         case CHAR_CS:
29025         case NCHAR_CS:
29026         case DBTIMEZONE:
29027         case SESSIONTIMEZONE:
29028         case AUTHENTICATED:
29029         case LINK:
29030         case SHARED:
29031         case DIRECTORY:
29032         case USER:
29033         case IDENTIFIER:
29034         case QUOTED_LITERAL:
29035         case SQLDATA_CLASS:
29036         case CUSTOMDATUM_CLASS:
29037         case ORADATA_CLASS:
29038         case JAVA_INTERFACE_CLASS:
29039           ;
29040           break;
29041         default:
29042           jj_la1[441] = jj_gen;
29043           break label_101;
29044         }
29045         switch (jj_nt.kind) {
29046         case AFTER:
29047         case BEFORE:
29048         case INSTEADOF:
29049           TriggerTimingPointSection();
29050           break;
29051         case PRAGMA:
29052           Pragma();
29053           break;
29054         default:
29055           jj_la1[442] = jj_gen;
29056           if (jj_2_81(2)) {
29057             ExceptionDeclaration();
29058           } else if (jj_2_82(2)) {
29059             SubTypeDefinition();
29060           } else if (jj_2_83(4)) {
29061             VariableOrConstantDeclaration();
29062           } else if (jj_2_84(2)) {
29063             CursorSpecification();
29064           } else {
29065             switch (jj_nt.kind) {
29066             case CURSOR:
29067               CursorBody();
29068               break;
29069             case IDENTIFIER:
29070               CollectionDeclaration();
29071               break;
29072             case CREATE:
29073             case FUNCTION:
29074             case PROCEDURE:
29075               ProgramUnit();
29076               break;
29077             default:
29078               jj_la1[443] = jj_gen;
29079               jj_consume_token(-1);
29080               throw new ParseException();
29081             }
29082           }
29083         }
29084       }
29085       jj_consume_token(END);
29086       switch (jj_nt.kind) {
29087       case REPLACE:
29088       case DEFINER:
29089       case CURRENT_USER:
29090       case SERIALLY_REUSABLE:
29091       case RESTRICT_REFERENCES:
29092       case EXCEPTION_INIT:
29093       case AUTONOMOUS_TRANSACTION:
29094       case LANGUAGE:
29095       case INLINE:
29096       case ADD:
29097       case AGGREGATE:
29098       case ALL:
29099       case ALTER:
29100       case AND:
29101       case ANY:
29102       case ARRAY:
29103       case AS:
29104       case ASC:
29105       case AT:
29106       case ATTRIBUTE:
29107       case AUTHID:
29108       case AVG:
29109       case BETWEEN:
29110       case BINARY_INTEGER:
29111       case BODY:
29112       case BOOLEAN:
29113       case BULK:
29114       case BY:
29115       case BYTE:
29116       case CASCADE:
29117       case CASE:
29118       case CHAR:
29119       case CHAR_BASE:
29120       case CHECK:
29121       case CLOSE:
29122       case CLUSTER:
29123       case COALESCE:
29124       case COLLECT:
29125       case COLUMN:
29126       case COMMENT:
29127       case COMMIT:
29128       case COMPRESS:
29129       case CONNECT:
29130       case CONSTANT:
29131       case CONSTRUCTOR:
29132       case CONTINUE:
29133       case CONVERT:
29134       case CREATE:
29135       case CURRENT:
29136       case CURRVAL:
29137       case CURSOR:
29138       case DATA:
29139       case DATE:
29140       case DAY:
29141       case DECLARE:
29142       case DECIMAL:
29143       case _DEFAULT:
29144       case DELETE:
29145       case DESC:
29146       case DISABLE:
29147       case DISTINCT:
29148       case DO:
29149       case DROP:
29150       case EDITIONABLE:
29151       case ELEMENT:
29152       case ELSE:
29153       case ELSIF:
29154       case ENABLE:
29155       case ESCAPE:
29156       case EXCEPT:
29157       case EXCEPTION:
29158       case EXCEPTIONS:
29159       case EXCLUSIVE:
29160       case EXECUTE:
29161       case EXISTS:
29162       case EXIT:
29163       case EXTERNAL:
29164       case EXTENDS:
29165       case EXTRACT:
29166       case FALSE:
29167       case FETCH:
29168       case FINAL:
29169       case FLOAT:
29170       case FOR:
29171       case FORALL:
29172       case FORCE:
29173       case FROM:
29174       case FUNCTION:
29175       case GLOBAL:
29176       case GOTO:
29177       case GROUP:
29178       case HASH:
29179       case HAVING:
29180       case HEAP:
29181       case HOUR:
29182       case IF:
29183       case IMMEDIATE:
29184       case IN:
29185       case INDEX:
29186       case INDICES:
29187       case INDEXTYPE:
29188       case INDICATOR:
29189       case INSERT:
29190       case INSTANTIABLE:
29191       case INTEGER:
29192       case INTERFACE:
29193       case INTERSECT:
29194       case INTERVAL:
29195       case INTO:
29196       case INVALIDATE:
29197       case IS:
29198       case ISOLATION:
29199       case JAVA:
29200       case LEVEL:
29201       case LIKE:
29202       case LIMIT:
29203       case LIMITED:
29204       case LOCK:
29205       case LONG:
29206       case LOOP:
29207       case MAP:
29208       case MAX:
29209       case MEMBER:
29210       case MERGE:
29211       case MIN:
29212       case MINUS:
29213       case MINUTE:
29214       case MLSLABEL:
29215       case MODIFY:
29216       case MOD:
29217       case MODE:
29218       case MONTH:
29219       case NATURAL:
29220       case NATURALN:
29221       case NEW:
29222       case NEXTVAL:
29223       case NO:
29224       case NOCOPY:
29225       case NONEDITIONABLE:
29226       case NOT:
29227       case NOWAIT:
29228       case NULL:
29229       case NULLIF:
29230       case NUMBER:
29231       case BFILE_BASE:
29232       case BLOB_BASE:
29233       case CLOB_BASE:
29234       case DATE_BASE:
29235       case NUMBER_BASE:
29236       case OBJECT:
29237       case OCIROWID:
29238       case OF:
29239       case OID:
29240       case ON:
29241       case OPAQUE:
29242       case OPEN:
29243       case OPERATOR:
29244       case OPTION:
29245       case OR:
29246       case ORDER:
29247       case ORGANIZATION:
29248       case OTHERS:
29249       case OUT:
29250       case OVERRIDING:
29251       case PACKAGE:
29252       case PARTITION:
29253       case PCTFREE:
29254       case PLS_INTEGER:
29255       case POSITIVE:
29256       case POSITIVEN:
29257       case PRESERVE:
29258       case PRIOR:
29259       case PROMPT:
29260       case PRIVATE:
29261       case PROCEDURE:
29262       case PUBLIC:
29263       case RAISE:
29264       case RANGE:
29265       case RAW:
29266       case REAL:
29267       case RECORD:
29268       case REF:
29269       case RELEASE:
29270       case RELIES_ON:
29271       case RENAME:
29272       case RESULT:
29273       case RETURN:
29274       case RETURNING:
29275       case REVERSE:
29276       case ROLLBACK:
29277       case ROW:
29278       case ROWS:
29279       case ROWID:
29280       case ROWNUM:
29281       case ROWTYPE:
29282       case SAVE:
29283       case SAVEPOINT:
29284       case SECOND:
29285       case SELECT:
29286       case SELF:
29287       case SEPARATE:
29288       case SET:
29289       case SHARE:
29290       case SMALLINT:
29291       case SPACE:
29292       case SQL:
29293       case SQLCODE:
29294       case SQLERRM:
29295       case START:
29296       case STATIC:
29297       case STDDEV:
29298       case SUBTYPE:
29299       case SUBSTITUTABLE:
29300       case SUCCESSFUL:
29301       case SUM:
29302       case SYNONYM:
29303       case SYSDATE:
29304       case SYS_REFCURSOR:
29305       case TABLE:
29306       case TEMPORARY:
29307       case THEN:
29308       case TIME:
29309       case TIMESTAMP:
29310       case TIMEZONE_REGION:
29311       case TIMEZONE_ABBR:
29312       case TIMEZONE_MINUTE:
29313       case TIMEZONE_HOUR:
29314       case TO:
29315       case TRANSACTION:
29316       case TRIGGER:
29317       case TRUE:
29318       case TYPE:
29319       case UI:
29320       case UNDER:
29321       case USING:
29322       case WHILE:
29323       case YES:
29324       case SHOW:
29325       case A:
29326       case UPDATE:
29327       case VARCHAR:
29328       case VARCHAR2:
29329       case DOUBLE:
29330       case DEC:
29331       case PRECISION:
29332       case INT:
29333       case NUMERIC:
29334       case SIGNTYPE:
29335       case NCHAR:
29336       case NVARCHAR2:
29337       case STRING:
29338       case UROWID:
29339       case VARRAY:
29340       case VARYING:
29341       case BFILE:
29342       case BLOB:
29343       case CLOB:
29344       case NCLOB:
29345       case YEAR:
29346       case LOCAL:
29347       case WITH:
29348       case ZONE:
29349       case CHARACTER:
29350       case AFTER:
29351       case BEFORE:
29352       case OLD:
29353       case PARENT:
29354       case ANALYZE:
29355       case ASSOCIATE:
29356       case AUDIT:
29357       case COMPOUND:
29358       case DATABASE:
29359       case CALL:
29360       case DDL:
29361       case DISASSOCIATE:
29362       case EACH:
29363       case FOLLOWS:
29364       case LOGOFF:
29365       case LOGON:
29366       case NESTED:
29367       case NOAUDIT:
29368       case SCHEMA:
29369       case SERVERERROR:
29370       case SHUTDOWN:
29371       case STARTUP:
29372       case STATEMENT:
29373       case STATISTICS:
29374       case SUSPEND:
29375       case TRUNCATE:
29376       case WRAPPED:
29377       case LIBRARY:
29378       case NAME:
29379       case STRUCT:
29380       case CONTEXT:
29381       case PARAMETERS:
29382       case LENGTH:
29383       case TDO:
29384       case MAXLEN:
29385       case CHARSETID:
29386       case CHARSETFORM:
29387       case ACCEPT:
29388       case ACCESSIBLE:
29389       case COPY:
29390       case DEFINE:
29391       case DISCONNECT:
29392       case HOST:
29393       case PRINT:
29394       case QUIT:
29395       case REMARK:
29396       case UNDEFINE:
29397       case VARIABLE:
29398       case WHENEVER:
29399       case ATTACH:
29400       case CAST:
29401       case TREAT:
29402       case TRIM:
29403       case LEFT:
29404       case RIGHT:
29405       case BOTH:
29406       case EMPTY:
29407       case MULTISET:
29408       case SUBMULTISET:
29409       case LEADING:
29410       case TRAILING:
29411       case CHAR_CS:
29412       case NCHAR_CS:
29413       case DBTIMEZONE:
29414       case SESSIONTIMEZONE:
29415       case AUTHENTICATED:
29416       case LINK:
29417       case SHARED:
29418       case DIRECTORY:
29419       case USER:
29420       case IDENTIFIER:
29421       case QUOTED_LITERAL:
29422       case SQLDATA_CLASS:
29423       case CUSTOMDATUM_CLASS:
29424       case ORADATA_CLASS:
29425       case JAVA_INTERFACE_CLASS:
29426         ID();
29427         break;
29428       default:
29429         jj_la1[444] = jj_gen;
29430         ;
29431       }
29432       jj_consume_token(4);
29433         jjtree.closeNodeScope(jjtn000, true);
29434         jjtc000 = false;
29435         {if (true) return jjtn000 ;}
29436     } catch (Throwable jjte000) {
29437     if (jjtc000) {
29438       jjtree.clearNodeScope(jjtn000);
29439       jjtc000 = false;
29440     } else {
29441       jjtree.popNode();
29442     }
29443     if (jjte000 instanceof RuntimeException) {
29444       {if (true) throw (RuntimeException)jjte000;}
29445     }
29446     if (jjte000 instanceof ParseException) {
29447       {if (true) throw (ParseException)jjte000;}
29448     }
29449     {if (true) throw (Error)jjte000;}
29450     } finally {
29451     if (jjtc000) {
29452       jjtree.closeNodeScope(jjtn000, true);
29453     }
29454     }
29455     throw new Error("Missing return statement in function");
29456   }
29457 
29458 /*
29459 non_dml_trigger :
29460 (BEFORE> |<AFTER> ) 
29461 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
29462 ON
29463 (DATABASE | [schema.]SCHEMA
29464 */
29465   final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
29466  /*@bgen(jjtree) NonDMLTrigger */
29467   ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
29468   boolean jjtc000 = true;
29469   jjtree.openNodeScope(jjtn000);
29470     try {
29471       switch (jj_nt.kind) {
29472       case BEFORE:
29473         jj_consume_token(BEFORE);
29474         break;
29475       case AFTER:
29476         jj_consume_token(AFTER);
29477         break;
29478       default:
29479         jj_la1[445] = jj_gen;
29480         jj_consume_token(-1);
29481         throw new ParseException();
29482       }
29483       switch (jj_nt.kind) {
29484       case ALTER:
29485       case COMMENT:
29486       case CREATE:
29487       case DROP:
29488       case GRANT:
29489       case RENAME:
29490       case REVOKE:
29491       case ANALYZE:
29492       case ASSOCIATE:
29493       case AUDIT:
29494       case DDL:
29495       case DISASSOCIATE:
29496       case NOAUDIT:
29497       case TRUNCATE:
29498         DDLEvent();
29499         break;
29500       case LOGOFF:
29501       case LOGON:
29502       case SERVERERROR:
29503       case SHUTDOWN:
29504       case STARTUP:
29505       case SUSPEND:
29506         DatabaseEvent();
29507         break;
29508       default:
29509         jj_la1[446] = jj_gen;
29510         jj_consume_token(-1);
29511         throw new ParseException();
29512       }
29513       label_102:
29514       while (true) {
29515         switch (jj_nt.kind) {
29516         case OR:
29517           ;
29518           break;
29519         default:
29520           jj_la1[447] = jj_gen;
29521           break label_102;
29522         }
29523         jj_consume_token(OR);
29524         switch (jj_nt.kind) {
29525         case ALTER:
29526         case COMMENT:
29527         case CREATE:
29528         case DROP:
29529         case GRANT:
29530         case RENAME:
29531         case REVOKE:
29532         case ANALYZE:
29533         case ASSOCIATE:
29534         case AUDIT:
29535         case DDL:
29536         case DISASSOCIATE:
29537         case NOAUDIT:
29538         case TRUNCATE:
29539           DDLEvent();
29540           break;
29541         case LOGOFF:
29542         case LOGON:
29543         case SERVERERROR:
29544         case SHUTDOWN:
29545         case STARTUP:
29546         case SUSPEND:
29547           DatabaseEvent();
29548           break;
29549         default:
29550           jj_la1[448] = jj_gen;
29551           jj_consume_token(-1);
29552           throw new ParseException();
29553         }
29554       }
29555       jj_consume_token(ON);
29556       switch (jj_nt.kind) {
29557       case DATABASE:
29558         jj_consume_token(DATABASE);
29559         break;
29560       case REPLACE:
29561       case DEFINER:
29562       case CURRENT_USER:
29563       case SERIALLY_REUSABLE:
29564       case RESTRICT_REFERENCES:
29565       case EXCEPTION_INIT:
29566       case AUTONOMOUS_TRANSACTION:
29567       case LANGUAGE:
29568       case INLINE:
29569       case ADD:
29570       case AGGREGATE:
29571       case ALL:
29572       case ALTER:
29573       case AND:
29574       case ANY:
29575       case ARRAY:
29576       case AS:
29577       case ASC:
29578       case AT:
29579       case ATTRIBUTE:
29580       case AUTHID:
29581       case AVG:
29582       case BETWEEN:
29583       case BINARY_INTEGER:
29584       case BODY:
29585       case BOOLEAN:
29586       case BULK:
29587       case BY:
29588       case BYTE:
29589       case CASCADE:
29590       case CASE:
29591       case CHAR:
29592       case CHAR_BASE:
29593       case CHECK:
29594       case CLOSE:
29595       case CLUSTER:
29596       case COALESCE:
29597       case COLLECT:
29598       case COLUMN:
29599       case COMMENT:
29600       case COMMIT:
29601       case COMPRESS:
29602       case CONNECT:
29603       case CONSTANT:
29604       case CONSTRUCTOR:
29605       case CONTINUE:
29606       case CONVERT:
29607       case CREATE:
29608       case CURRENT:
29609       case CURRVAL:
29610       case CURSOR:
29611       case DATA:
29612       case DATE:
29613       case DAY:
29614       case DECLARE:
29615       case DECIMAL:
29616       case _DEFAULT:
29617       case DELETE:
29618       case DESC:
29619       case DISABLE:
29620       case DISTINCT:
29621       case DO:
29622       case DROP:
29623       case EDITIONABLE:
29624       case ELEMENT:
29625       case ELSE:
29626       case ELSIF:
29627       case ENABLE:
29628       case ESCAPE:
29629       case EXCEPT:
29630       case EXCEPTION:
29631       case EXCEPTIONS:
29632       case EXCLUSIVE:
29633       case EXECUTE:
29634       case EXISTS:
29635       case EXIT:
29636       case EXTERNAL:
29637       case EXTENDS:
29638       case EXTRACT:
29639       case FALSE:
29640       case FETCH:
29641       case FINAL:
29642       case FLOAT:
29643       case FOR:
29644       case FORALL:
29645       case FORCE:
29646       case FROM:
29647       case FUNCTION:
29648       case GLOBAL:
29649       case GOTO:
29650       case GROUP:
29651       case HASH:
29652       case HAVING:
29653       case HEAP:
29654       case HOUR:
29655       case IF:
29656       case IMMEDIATE:
29657       case IN:
29658       case INDEX:
29659       case INDICES:
29660       case INDEXTYPE:
29661       case INDICATOR:
29662       case INSERT:
29663       case INSTANTIABLE:
29664       case INTEGER:
29665       case INTERFACE:
29666       case INTERSECT:
29667       case INTERVAL:
29668       case INTO:
29669       case INVALIDATE:
29670       case IS:
29671       case ISOLATION:
29672       case JAVA:
29673       case LEVEL:
29674       case LIKE:
29675       case LIMIT:
29676       case LIMITED:
29677       case LOCK:
29678       case LONG:
29679       case LOOP:
29680       case MAP:
29681       case MAX:
29682       case MEMBER:
29683       case MERGE:
29684       case MIN:
29685       case MINUS:
29686       case MINUTE:
29687       case MLSLABEL:
29688       case MODIFY:
29689       case MOD:
29690       case MODE:
29691       case MONTH:
29692       case NATURAL:
29693       case NATURALN:
29694       case NEW:
29695       case NEXTVAL:
29696       case NO:
29697       case NOCOPY:
29698       case NONEDITIONABLE:
29699       case NOT:
29700       case NOWAIT:
29701       case NULL:
29702       case NULLIF:
29703       case NUMBER:
29704       case BFILE_BASE:
29705       case BLOB_BASE:
29706       case CLOB_BASE:
29707       case DATE_BASE:
29708       case NUMBER_BASE:
29709       case OBJECT:
29710       case OCIROWID:
29711       case OF:
29712       case OID:
29713       case ON:
29714       case OPAQUE:
29715       case OPEN:
29716       case OPERATOR:
29717       case OPTION:
29718       case OR:
29719       case ORDER:
29720       case ORGANIZATION:
29721       case OTHERS:
29722       case OUT:
29723       case OVERRIDING:
29724       case PACKAGE:
29725       case PARTITION:
29726       case PCTFREE:
29727       case PLS_INTEGER:
29728       case POSITIVE:
29729       case POSITIVEN:
29730       case PRESERVE:
29731       case PRIOR:
29732       case PROMPT:
29733       case PRIVATE:
29734       case PROCEDURE:
29735       case PUBLIC:
29736       case RAISE:
29737       case RANGE:
29738       case RAW:
29739       case REAL:
29740       case RECORD:
29741       case REF:
29742       case RELEASE:
29743       case RELIES_ON:
29744       case RENAME:
29745       case RESULT:
29746       case RETURN:
29747       case RETURNING:
29748       case REVERSE:
29749       case ROLLBACK:
29750       case ROW:
29751       case ROWS:
29752       case ROWID:
29753       case ROWNUM:
29754       case ROWTYPE:
29755       case SAVE:
29756       case SAVEPOINT:
29757       case SECOND:
29758       case SELECT:
29759       case SELF:
29760       case SEPARATE:
29761       case SET:
29762       case SHARE:
29763       case SMALLINT:
29764       case SPACE:
29765       case SQL:
29766       case SQLCODE:
29767       case SQLERRM:
29768       case START:
29769       case STATIC:
29770       case STDDEV:
29771       case SUBTYPE:
29772       case SUBSTITUTABLE:
29773       case SUCCESSFUL:
29774       case SUM:
29775       case SYNONYM:
29776       case SYSDATE:
29777       case SYS_REFCURSOR:
29778       case TABLE:
29779       case TEMPORARY:
29780       case THEN:
29781       case TIME:
29782       case TIMESTAMP:
29783       case TIMEZONE_REGION:
29784       case TIMEZONE_ABBR:
29785       case TIMEZONE_MINUTE:
29786       case TIMEZONE_HOUR:
29787       case TO:
29788       case TRANSACTION:
29789       case TRIGGER:
29790       case TRUE:
29791       case TYPE:
29792       case UI:
29793       case UNDER:
29794       case USING:
29795       case WHILE:
29796       case YES:
29797       case SHOW:
29798       case A:
29799       case UPDATE:
29800       case VARCHAR:
29801       case VARCHAR2:
29802       case DOUBLE:
29803       case DEC:
29804       case PRECISION:
29805       case INT:
29806       case NUMERIC:
29807       case SIGNTYPE:
29808       case NCHAR:
29809       case NVARCHAR2:
29810       case STRING:
29811       case UROWID:
29812       case VARRAY:
29813       case VARYING:
29814       case BFILE:
29815       case BLOB:
29816       case CLOB:
29817       case NCLOB:
29818       case YEAR:
29819       case LOCAL:
29820       case WITH:
29821       case ZONE:
29822       case CHARACTER:
29823       case AFTER:
29824       case BEFORE:
29825       case OLD:
29826       case PARENT:
29827       case ANALYZE:
29828       case ASSOCIATE:
29829       case AUDIT:
29830       case COMPOUND:
29831       case CALL:
29832       case DDL:
29833       case DISASSOCIATE:
29834       case EACH:
29835       case FOLLOWS:
29836       case LOGOFF:
29837       case LOGON:
29838       case NESTED:
29839       case NOAUDIT:
29840       case SCHEMA:
29841       case SERVERERROR:
29842       case SHUTDOWN:
29843       case STARTUP:
29844       case STATEMENT:
29845       case STATISTICS:
29846       case SUSPEND:
29847       case TRUNCATE:
29848       case WRAPPED:
29849       case LIBRARY:
29850       case NAME:
29851       case STRUCT:
29852       case CONTEXT:
29853       case PARAMETERS:
29854       case LENGTH:
29855       case TDO:
29856       case MAXLEN:
29857       case CHARSETID:
29858       case CHARSETFORM:
29859       case ACCEPT:
29860       case ACCESSIBLE:
29861       case COPY:
29862       case DEFINE:
29863       case DISCONNECT:
29864       case HOST:
29865       case PRINT:
29866       case QUIT:
29867       case REMARK:
29868       case UNDEFINE:
29869       case VARIABLE:
29870       case WHENEVER:
29871       case ATTACH:
29872       case CAST:
29873       case TREAT:
29874       case TRIM:
29875       case LEFT:
29876       case RIGHT:
29877       case BOTH:
29878       case EMPTY:
29879       case MULTISET:
29880       case SUBMULTISET:
29881       case LEADING:
29882       case TRAILING:
29883       case CHAR_CS:
29884       case NCHAR_CS:
29885       case DBTIMEZONE:
29886       case SESSIONTIMEZONE:
29887       case AUTHENTICATED:
29888       case LINK:
29889       case SHARED:
29890       case DIRECTORY:
29891       case USER:
29892       case IDENTIFIER:
29893       case QUOTED_LITERAL:
29894       case SQLDATA_CLASS:
29895       case CUSTOMDATUM_CLASS:
29896       case ORADATA_CLASS:
29897       case JAVA_INTERFACE_CLASS:
29898         if (jj_2_85(2)) {
29899           ID();
29900           jj_consume_token(3);
29901         } else {
29902           ;
29903         }
29904         jj_consume_token(SCHEMA);
29905         break;
29906       default:
29907         jj_la1[449] = jj_gen;
29908         jj_consume_token(-1);
29909         throw new ParseException();
29910       }
29911         jjtree.closeNodeScope(jjtn000, true);
29912         jjtc000 = false;
29913         {if (true) return jjtn000 ;}
29914     } catch (Throwable jjte000) {
29915    if (jjtc000) {
29916      jjtree.clearNodeScope(jjtn000);
29917      jjtc000 = false;
29918    } else {
29919      jjtree.popNode();
29920    }
29921    if (jjte000 instanceof RuntimeException) {
29922      {if (true) throw (RuntimeException)jjte000;}
29923    }
29924    if (jjte000 instanceof ParseException) {
29925      {if (true) throw (ParseException)jjte000;}
29926    }
29927    {if (true) throw (Error)jjte000;}
29928     } finally {
29929    if (jjtc000) {
29930      jjtree.closeNodeScope(jjtn000, true);
29931    }
29932     }
29933     throw new Error("Missing return statement in function");
29934   }
29935 
29936   final public ASTDDLEvent DDLEvent() throws ParseException {
29937                          /*@bgen(jjtree) DDLEvent */
29938   ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29939   boolean jjtc000 = true;
29940   jjtree.openNodeScope(jjtn000);
29941     try {
29942       switch (jj_nt.kind) {
29943       case ALTER:
29944         jj_consume_token(ALTER);
29945         break;
29946       case ANALYZE:
29947         jj_consume_token(ANALYZE);
29948         break;
29949       case ASSOCIATE:
29950         jj_consume_token(ASSOCIATE);
29951         jj_consume_token(STATISTICS);
29952         break;
29953       case AUDIT:
29954         jj_consume_token(AUDIT);
29955         break;
29956       case COMMENT:
29957         jj_consume_token(COMMENT);
29958         break;
29959       case CREATE:
29960         jj_consume_token(CREATE);
29961         break;
29962       case DISASSOCIATE:
29963         jj_consume_token(DISASSOCIATE);
29964         jj_consume_token(STATISTICS);
29965         break;
29966       case DROP:
29967         jj_consume_token(DROP);
29968         break;
29969       case GRANT:
29970         jj_consume_token(GRANT);
29971         break;
29972       case NOAUDIT:
29973         jj_consume_token(NOAUDIT);
29974         break;
29975       case RENAME:
29976         jj_consume_token(RENAME);
29977         break;
29978       case REVOKE:
29979         jj_consume_token(REVOKE);
29980         break;
29981       case TRUNCATE:
29982         jj_consume_token(TRUNCATE);
29983         break;
29984       case DDL:
29985         jj_consume_token(DDL);
29986         break;
29987       default:
29988         jj_la1[450] = jj_gen;
29989         jj_consume_token(-1);
29990         throw new ParseException();
29991       }
29992           jjtree.closeNodeScope(jjtn000, true);
29993           jjtc000 = false;
29994           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29995     } finally {
29996     if (jjtc000) {
29997       jjtree.closeNodeScope(jjtn000, true);
29998     }
29999     }
30000     throw new Error("Missing return statement in function");
30001   }
30002 
30003   final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
30004                                    /*@bgen(jjtree) DatabaseEvent */
30005   ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
30006   boolean jjtc000 = true;
30007   jjtree.openNodeScope(jjtn000);
30008     try {
30009       switch (jj_nt.kind) {
30010       case STARTUP:
30011         jj_consume_token(STARTUP);
30012         break;
30013       case SHUTDOWN:
30014         jj_consume_token(SHUTDOWN);
30015         break;
30016       case LOGON:
30017         jj_consume_token(LOGON);
30018         break;
30019       case LOGOFF:
30020         jj_consume_token(LOGOFF);
30021         break;
30022       case SERVERERROR:
30023         jj_consume_token(SERVERERROR);
30024         break;
30025       case SUSPEND:
30026         jj_consume_token(SUSPEND);
30027         break;
30028       default:
30029         jj_la1[451] = jj_gen;
30030         jj_consume_token(-1);
30031         throw new ParseException();
30032       }
30033           jjtree.closeNodeScope(jjtn000, true);
30034           jjtc000 = false;
30035           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30036     } finally {
30037     if (jjtc000) {
30038       jjtree.closeNodeScope(jjtn000, true);
30039     }
30040     }
30041     throw new Error("Missing return statement in function");
30042   }
30043 
30044   final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
30045                                /*@bgen(jjtree) NonDMLEvent */
30046   ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
30047   boolean jjtc000 = true;
30048   jjtree.openNodeScope(jjtn000);
30049     try {
30050       switch (jj_nt.kind) {
30051       case ALTER:
30052       case COMMENT:
30053       case CREATE:
30054       case DROP:
30055       case GRANT:
30056       case RENAME:
30057       case REVOKE:
30058       case ANALYZE:
30059       case ASSOCIATE:
30060       case AUDIT:
30061       case DDL:
30062       case DISASSOCIATE:
30063       case NOAUDIT:
30064       case TRUNCATE:
30065         DDLEvent();
30066         break;
30067       case LOGOFF:
30068       case LOGON:
30069       case SERVERERROR:
30070       case SHUTDOWN:
30071       case STARTUP:
30072       case SUSPEND:
30073         DatabaseEvent();
30074         break;
30075       default:
30076         jj_la1[452] = jj_gen;
30077         jj_consume_token(-1);
30078         throw new ParseException();
30079       }
30080     jjtree.closeNodeScope(jjtn000, true);
30081     jjtc000 = false;
30082     {if (true) return jjtn000;}
30083     } catch (Throwable jjte000) {
30084     if (jjtc000) {
30085       jjtree.clearNodeScope(jjtn000);
30086       jjtc000 = false;
30087     } else {
30088       jjtree.popNode();
30089     }
30090     if (jjte000 instanceof RuntimeException) {
30091       {if (true) throw (RuntimeException)jjte000;}
30092     }
30093     if (jjte000 instanceof ParseException) {
30094       {if (true) throw (ParseException)jjte000;}
30095     }
30096     {if (true) throw (Error)jjte000;}
30097     } finally {
30098     if (jjtc000) {
30099       jjtree.closeNodeScope(jjtn000, true);
30100     }
30101     }
30102     throw new Error("Missing return statement in function");
30103   }
30104 
30105 /*
30106 When DBMS_METADATA.GET_DDL returns a trigger, it can come in 2 DDL statements.
30107 The first is the CREATE OR REPLACE TRIGER statement; the second is an ALTER TRIGGER statement,
30108 enabling or disabling the trigger.
30109 
30110 Unlike the ALTER TYPE, it does not seem to alter the structure of the object.
30111 */
30112   final public void AlterTrigger() throws ParseException {
30113  /*@bgen(jjtree) AlterTrigger */
30114   ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
30115   boolean jjtc000 = true;
30116   jjtree.openNodeScope(jjtn000);
30117     try {
30118       jj_consume_token(ALTER);
30119       jj_consume_token(TRIGGER);
30120       Skip2NextTerminator(null,";");
30121       jj_consume_token(4);
30122           jjtree.closeNodeScope(jjtn000, true);
30123           jjtc000 = false;
30124                 {if (true) return;}
30125     } catch (Throwable jjte000) {
30126           if (jjtc000) {
30127             jjtree.clearNodeScope(jjtn000);
30128             jjtc000 = false;
30129           } else {
30130             jjtree.popNode();
30131           }
30132           if (jjte000 instanceof RuntimeException) {
30133             {if (true) throw (RuntimeException)jjte000;}
30134           }
30135           if (jjte000 instanceof ParseException) {
30136             {if (true) throw (ParseException)jjte000;}
30137           }
30138           {if (true) throw (Error)jjte000;}
30139     } finally {
30140           if (jjtc000) {
30141             jjtree.closeNodeScope(jjtn000, true);
30142           }
30143     }
30144   }
30145 
30146 //SRT 2011-04-17 - START 
30147   final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
30148                                           /*@bgen(jjtree) KEYWORD_RESERVED */
30149   ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
30150   boolean jjtc000 = true;
30151   jjtree.openNodeScope(jjtn000);
30152     try {
30153       switch (jj_nt.kind) {
30154       case ALL:
30155         jj_consume_token(ALL);
30156         break;
30157       case ALTER:
30158         jj_consume_token(ALTER);
30159         break;
30160       case AND:
30161         jj_consume_token(AND);
30162         break;
30163       case ANY:
30164         jj_consume_token(ANY);
30165         break;
30166       case AS:
30167         jj_consume_token(AS);
30168         break;
30169       case ASC:
30170         jj_consume_token(ASC);
30171         break;
30172       case BETWEEN:
30173         jj_consume_token(BETWEEN);
30174         break;
30175       case BY:
30176         jj_consume_token(BY);
30177         break;
30178       case CHAR:
30179         jj_consume_token(CHAR);
30180         break;
30181       case CHECK:
30182         jj_consume_token(CHECK);
30183         break;
30184       case CLUSTER:
30185         jj_consume_token(CLUSTER);
30186         break;
30187       case COMPRESS:
30188         jj_consume_token(COMPRESS);
30189         break;
30190       case CONNECT:
30191         jj_consume_token(CONNECT);
30192         break;
30193       case CREATE:
30194         jj_consume_token(CREATE);
30195         break;
30196       case DATE:
30197         jj_consume_token(DATE);
30198         break;
30199       case DECIMAL:
30200         jj_consume_token(DECIMAL);
30201         break;
30202       case _DEFAULT:
30203         jj_consume_token(_DEFAULT);
30204         break;
30205       case DELETE:
30206         jj_consume_token(DELETE);
30207         break;
30208       case DESC:
30209         jj_consume_token(DESC);
30210         break;
30211       case DISTINCT:
30212         jj_consume_token(DISTINCT);
30213         break;
30214       case DROP:
30215         jj_consume_token(DROP);
30216         break;
30217       case ELSE:
30218         jj_consume_token(ELSE);
30219         break;
30220       case EXCLUSIVE:
30221         jj_consume_token(EXCLUSIVE);
30222         break;
30223       case EXISTS:
30224         jj_consume_token(EXISTS);
30225         break;
30226       case FLOAT:
30227         jj_consume_token(FLOAT);
30228         break;
30229       case FOR:
30230         jj_consume_token(FOR);
30231         break;
30232       case FROM:
30233         jj_consume_token(FROM);
30234         break;
30235       case GRANT:
30236         jj_consume_token(GRANT);
30237         break;
30238       case GROUP:
30239         jj_consume_token(GROUP);
30240         break;
30241       case HAVING:
30242         jj_consume_token(HAVING);
30243         break;
30244       case IDENTIFIED:
30245         jj_consume_token(IDENTIFIED);
30246         break;
30247       case IN:
30248         jj_consume_token(IN);
30249         break;
30250       case INDEX:
30251         jj_consume_token(INDEX);
30252         break;
30253       case INSERT:
30254         jj_consume_token(INSERT);
30255         break;
30256       case INTEGER:
30257         jj_consume_token(INTEGER);
30258         break;
30259       case INTERSECT:
30260         jj_consume_token(INTERSECT);
30261         break;
30262       case INTO:
30263         jj_consume_token(INTO);
30264         break;
30265       case IS:
30266         jj_consume_token(IS);
30267         break;
30268       case LIKE:
30269         jj_consume_token(LIKE);
30270         break;
30271       case LOCK:
30272         jj_consume_token(LOCK);
30273         break;
30274       case LONG:
30275         jj_consume_token(LONG);
30276         break;
30277       case MINUS:
30278         jj_consume_token(MINUS);
30279         break;
30280       case MODE:
30281         jj_consume_token(MODE);
30282         break;
30283       case NOCOMPRESS:
30284         jj_consume_token(NOCOMPRESS);
30285         break;
30286       case NOT:
30287         jj_consume_token(NOT);
30288         break;
30289       case NOWAIT:
30290         jj_consume_token(NOWAIT);
30291         break;
30292       case NULL:
30293         jj_consume_token(NULL);
30294         break;
30295       case NUMBER:
30296         jj_consume_token(NUMBER);
30297         break;
30298       case OF:
30299         jj_consume_token(OF);
30300         break;
30301       case ON:
30302         jj_consume_token(ON);
30303         break;
30304       case OPTION:
30305         jj_consume_token(OPTION);
30306         break;
30307       case OR:
30308         jj_consume_token(OR);
30309         break;
30310       case ORDER:
30311         jj_consume_token(ORDER);
30312         break;
30313       case PCTFREE:
30314         jj_consume_token(PCTFREE);
30315         break;
30316       case PRIOR:
30317         jj_consume_token(PRIOR);
30318         break;
30319       case PUBLIC:
30320         jj_consume_token(PUBLIC);
30321         break;
30322       case RAW:
30323         jj_consume_token(RAW);
30324         break;
30325       case RESOURCE:
30326         jj_consume_token(RESOURCE);
30327         break;
30328       case REVOKE:
30329         jj_consume_token(REVOKE);
30330         break;
30331       case SELECT:
30332         jj_consume_token(SELECT);
30333         break;
30334       case SET:
30335         jj_consume_token(SET);
30336         break;
30337       case SHARE:
30338         jj_consume_token(SHARE);
30339         break;
30340       case SIZE:
30341         jj_consume_token(SIZE);
30342         break;
30343       case SMALLINT:
30344         jj_consume_token(SMALLINT);
30345         break;
30346       case START:
30347         jj_consume_token(START);
30348         break;
30349       case SYNONYM:
30350         jj_consume_token(SYNONYM);
30351         break;
30352       case TABLE:
30353         jj_consume_token(TABLE);
30354         break;
30355       case THEN:
30356         jj_consume_token(THEN);
30357         break;
30358       case TO:
30359         jj_consume_token(TO);
30360         break;
30361       case TRIGGER:
30362         jj_consume_token(TRIGGER);
30363         break;
30364       case UNION:
30365         jj_consume_token(UNION);
30366         break;
30367       case UNIQUE:
30368         jj_consume_token(UNIQUE);
30369         break;
30370       case UPDATE:
30371         jj_consume_token(UPDATE);
30372         break;
30373       case VALUES:
30374         jj_consume_token(VALUES);
30375         break;
30376       case VARCHAR:
30377         jj_consume_token(VARCHAR);
30378         break;
30379       case VARCHAR2:
30380         jj_consume_token(VARCHAR2);
30381         break;
30382       case VIEW:
30383         jj_consume_token(VIEW);
30384         break;
30385       case WHERE:
30386         jj_consume_token(WHERE);
30387         break;
30388       case WITH:
30389         jj_consume_token(WITH);
30390         break;
30391       default:
30392         jj_la1[453] = jj_gen;
30393         jj_consume_token(-1);
30394         throw new ParseException();
30395       }
30396    jjtree.closeNodeScope(jjtn000, true);
30397    jjtc000 = false;
30398    jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30399     } finally {
30400   if (jjtc000) {
30401     jjtree.closeNodeScope(jjtn000, true);
30402   }
30403     }
30404     throw new Error("Missing return statement in function");
30405   }
30406 
30407   final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
30408                                               /*@bgen(jjtree) KEYWORD_UNRESERVED */
30409   ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
30410   boolean jjtc000 = true;
30411   jjtree.openNodeScope(jjtn000);
30412     try {
30413       switch (jj_nt.kind) {
30414       case FALSE:
30415         jj_consume_token(FALSE);
30416         break;
30417       case TRUE:
30418         jj_consume_token(TRUE);
30419         break;
30420       case A:
30421         jj_consume_token(A);
30422         break;
30423       case ACCEPT:
30424         jj_consume_token(ACCEPT);
30425         break;
30426       case ADD:
30427         jj_consume_token(ADD);
30428         break;
30429       case AFTER:
30430         jj_consume_token(AFTER);
30431         break;
30432       case AGGREGATE:
30433         jj_consume_token(AGGREGATE);
30434         break;
30435       case ANALYZE:
30436         jj_consume_token(ANALYZE);
30437         break;
30438       case ASSOCIATE:
30439         jj_consume_token(ASSOCIATE);
30440         break;
30441       case AT:
30442         jj_consume_token(AT);
30443         break;
30444       case ATTACH:
30445         jj_consume_token(ATTACH);
30446         break;
30447       case ATTRIBUTE:
30448         jj_consume_token(ATTRIBUTE);
30449         break;
30450       case AUDIT:
30451         jj_consume_token(AUDIT);
30452         break;
30453       case AUTHENTICATED:
30454         jj_consume_token(AUTHENTICATED);
30455         break;
30456       case AUTHID:
30457         jj_consume_token(AUTHID);
30458         break;
30459       case BEFORE:
30460         jj_consume_token(BEFORE);
30461         break;
30462       case BFILE:
30463         jj_consume_token(BFILE);
30464         break;
30465       case BLOB:
30466         jj_consume_token(BLOB);
30467         break;
30468       case BOTH:
30469         jj_consume_token(BOTH);
30470         break;
30471       case BULK:
30472         jj_consume_token(BULK);
30473         break;
30474       case BYTE:
30475         jj_consume_token(BYTE);
30476         break;
30477       case CALL:
30478         jj_consume_token(CALL);
30479         break;
30480       case CASCADE:
30481         jj_consume_token(CASCADE);
30482         break;
30483       case CAST:
30484         jj_consume_token(CAST);
30485         break;
30486       case CHAR_CS:
30487         jj_consume_token(CHAR_CS);
30488         break;
30489       case CHARACTER:
30490         jj_consume_token(CHARACTER);
30491         break;
30492       case CHARSETFORM:
30493         jj_consume_token(CHARSETFORM);
30494         break;
30495       case CHARSETID:
30496         jj_consume_token(CHARSETID);
30497         break;
30498       case CLOB:
30499         jj_consume_token(CLOB);
30500         break;
30501       case CLOSE:
30502         jj_consume_token(CLOSE);
30503         break;
30504       case COALESCE:
30505         jj_consume_token(COALESCE);
30506         break;
30507       case COLLECT:
30508         jj_consume_token(COLLECT);
30509         break;
30510       case COLUMN:
30511         jj_consume_token(COLUMN);
30512         break;
30513       case COMMENT:
30514         jj_consume_token(COMMENT);
30515         break;
30516       case COMMIT:
30517         jj_consume_token(COMMIT);
30518         break;
30519       case COMPOUND:
30520         jj_consume_token(COMPOUND);
30521         break;
30522       case CONSTRUCTOR:
30523         jj_consume_token(CONSTRUCTOR);
30524         break;
30525       case CONTEXT:
30526         jj_consume_token(CONTEXT);
30527         break;
30528       case CONTINUE:
30529         jj_consume_token(CONTINUE);
30530         break;
30531       case CONVERT:
30532         jj_consume_token(CONVERT);
30533         break;
30534       case COPY:
30535         jj_consume_token(COPY);
30536         break;
30537       case CURRENT:
30538         jj_consume_token(CURRENT);
30539         break;
30540       case CURRENT_USER:
30541         jj_consume_token(CURRENT_USER);
30542         break;
30543       case CURSOR:
30544         jj_consume_token(CURSOR);
30545         break;
30546       case DATA:
30547         jj_consume_token(DATA);
30548         break;
30549       case DATABASE:
30550         jj_consume_token(DATABASE);
30551         break;
30552       case DAY:
30553         jj_consume_token(DAY);
30554         break;
30555       case DBTIMEZONE:
30556         jj_consume_token(DBTIMEZONE);
30557         break;
30558       case DDL:
30559         jj_consume_token(DDL);
30560         break;
30561       case DEC:
30562         jj_consume_token(DEC);
30563         break;
30564       case DEFINE:
30565         jj_consume_token(DEFINE);
30566         break;
30567       case DEFINER:
30568         jj_consume_token(DEFINER);
30569         break;
30570       case DIRECTORY:
30571         jj_consume_token(DIRECTORY);
30572         break;
30573       case DISABLE:
30574         jj_consume_token(DISABLE);
30575         break;
30576       case DISASSOCIATE:
30577         jj_consume_token(DISASSOCIATE);
30578         break;
30579       case DISCONNECT:
30580         jj_consume_token(DISCONNECT);
30581         break;
30582       case DOUBLE:
30583         jj_consume_token(DOUBLE);
30584         break;
30585       case EACH:
30586         jj_consume_token(EACH);
30587         break;
30588       case ELEMENT:
30589         jj_consume_token(ELEMENT);
30590         break;
30591       case EMPTY:
30592         jj_consume_token(EMPTY);
30593         break;
30594       case ENABLE:
30595         jj_consume_token(ENABLE);
30596         break;
30597       case ESCAPE:
30598         jj_consume_token(ESCAPE);
30599         break;
30600       case EXCEPT:
30601         jj_consume_token(EXCEPT);
30602         break;
30603       case EXCEPTIONS:
30604         jj_consume_token(EXCEPTIONS);
30605         break;
30606       case EXIT:
30607         jj_consume_token(EXIT);
30608         break;
30609       case EXTENDS:
30610         jj_consume_token(EXTENDS);
30611         break;
30612       case EXTERNAL:
30613         jj_consume_token(EXTERNAL);
30614         break;
30615       case EXTRACT:
30616         jj_consume_token(EXTRACT);
30617         break;
30618       case FINAL:
30619         jj_consume_token(FINAL);
30620         break;
30621       case FOLLOWS:
30622         jj_consume_token(FOLLOWS);
30623         break;
30624       case FORCE:
30625         jj_consume_token(FORCE);
30626         break;
30627       case FUNCTION:
30628         jj_consume_token(FUNCTION);
30629         break;
30630       case GLOBAL:
30631         jj_consume_token(GLOBAL);
30632         break;
30633       case HASH:
30634         jj_consume_token(HASH);
30635         break;
30636       case HEAP:
30637         jj_consume_token(HEAP);
30638         break;
30639       case HOST:
30640         jj_consume_token(HOST);
30641         break;
30642       case HOUR:
30643         jj_consume_token(HOUR);
30644         break;
30645       case IMMEDIATE:
30646         jj_consume_token(IMMEDIATE);
30647         break;
30648       case INDEXTYPE:
30649         jj_consume_token(INDEXTYPE);
30650         break;
30651       case INDICATOR:
30652         jj_consume_token(INDICATOR);
30653         break;
30654       case INDICES:
30655         jj_consume_token(INDICES);
30656         break;
30657       case INSTANTIABLE:
30658         jj_consume_token(INSTANTIABLE);
30659         break;
30660       case INTERVAL:
30661         jj_consume_token(INTERVAL);
30662         break;
30663       case INVALIDATE:
30664         jj_consume_token(INVALIDATE);
30665         break;
30666       case ISOLATION:
30667         jj_consume_token(ISOLATION);
30668         break;
30669       case JAVA:
30670         jj_consume_token(JAVA);
30671         break;
30672       case LANGUAGE:
30673         jj_consume_token(LANGUAGE);
30674         break;
30675       case LEADING:
30676         jj_consume_token(LEADING);
30677         break;
30678       case LEFT:
30679         jj_consume_token(LEFT);
30680         break;
30681       case LENGTH:
30682         jj_consume_token(LENGTH);
30683         break;
30684       case LEVEL:
30685         jj_consume_token(LEVEL);
30686         break;
30687       case LIBRARY:
30688         jj_consume_token(LIBRARY);
30689         break;
30690       case LIMIT:
30691         jj_consume_token(LIMIT);
30692         break;
30693       case LINK:
30694         jj_consume_token(LINK);
30695         break;
30696       case LOCAL:
30697         jj_consume_token(LOCAL);
30698         break;
30699       case LOGOFF:
30700         jj_consume_token(LOGOFF);
30701         break;
30702       case LOGON:
30703         jj_consume_token(LOGON);
30704         break;
30705       case MAP:
30706         jj_consume_token(MAP);
30707         break;
30708       case MAX:
30709         jj_consume_token(MAX);
30710         break;
30711       case MAXLEN:
30712         jj_consume_token(MAXLEN);
30713         break;
30714       case MEMBER:
30715         jj_consume_token(MEMBER);
30716         break;
30717       case MERGE:
30718         jj_consume_token(MERGE);
30719         break;
30720       case MIN:
30721         jj_consume_token(MIN);
30722         break;
30723       case MINUTE:
30724         jj_consume_token(MINUTE);
30725         break;
30726       case MLSLABEL:
30727         jj_consume_token(MLSLABEL);
30728         break;
30729       case MODIFY:
30730         jj_consume_token(MODIFY);
30731         break;
30732       case MONTH:
30733         jj_consume_token(MONTH);
30734         break;
30735       case MULTISET:
30736         jj_consume_token(MULTISET);
30737         break;
30738       case NAME:
30739         jj_consume_token(NAME);
30740         break;
30741       case NATURAL:
30742         jj_consume_token(NATURAL);
30743         break;
30744       case NCHAR:
30745         jj_consume_token(NCHAR);
30746         break;
30747       case NCHAR_CS:
30748         jj_consume_token(NCHAR_CS);
30749         break;
30750       case NCLOB:
30751         jj_consume_token(NCLOB);
30752         break;
30753       case NESTED:
30754         jj_consume_token(NESTED);
30755         break;
30756       case NEW:
30757         jj_consume_token(NEW);
30758         break;
30759       case NO:
30760         jj_consume_token(NO);
30761         break;
30762       case NOAUDIT:
30763         jj_consume_token(NOAUDIT);
30764         break;
30765       case NUMERIC:
30766         jj_consume_token(NUMERIC);
30767         break;
30768       case NVARCHAR2:
30769         jj_consume_token(NVARCHAR2);
30770         break;
30771       case OBJECT:
30772         jj_consume_token(OBJECT);
30773         break;
30774       case OID:
30775         jj_consume_token(OID);
30776         break;
30777       case OLD:
30778         jj_consume_token(OLD);
30779         break;
30780       case OPAQUE:
30781         jj_consume_token(OPAQUE);
30782         break;
30783       case OPEN:
30784         jj_consume_token(OPEN);
30785         break;
30786       case ORGANIZATION:
30787         jj_consume_token(ORGANIZATION);
30788         break;
30789       case OTHERS:
30790         jj_consume_token(OTHERS);
30791         break;
30792       case OVERRIDING:
30793         jj_consume_token(OVERRIDING);
30794         break;
30795       case PACKAGE:
30796         jj_consume_token(PACKAGE);
30797         break;
30798       case PARAMETERS:
30799         jj_consume_token(PARAMETERS);
30800         break;
30801       case PARENT:
30802         jj_consume_token(PARENT);
30803         break;
30804       case PARTITION:
30805         jj_consume_token(PARTITION);
30806         break;
30807       case PRECISION:
30808         jj_consume_token(PRECISION);
30809         break;
30810       case PRESERVE:
30811         jj_consume_token(PRESERVE);
30812         break;
30813       case PRINT:
30814         jj_consume_token(PRINT);
30815         break;
30816       case PROCEDURE:
30817         jj_consume_token(PROCEDURE);
30818         break;
30819       case QUIT:
30820         jj_consume_token(QUIT);
30821         break;
30822       case RANGE:
30823         jj_consume_token(RANGE);
30824         break;
30825       case REAL:
30826         jj_consume_token(REAL);
30827         break;
30828       case RECORD:
30829         jj_consume_token(RECORD);
30830         break;
30831       case REF:
30832         jj_consume_token(REF);
30833         break;
30834       case RELIES_ON:
30835         jj_consume_token(RELIES_ON);
30836         break;
30837       case REMARK:
30838         jj_consume_token(REMARK);
30839         break;
30840       case RESULT:
30841         jj_consume_token(RESULT);
30842         break;
30843       case RETURN:
30844         jj_consume_token(RETURN);
30845         break;
30846       case RETURNING:
30847         jj_consume_token(RETURNING);
30848         break;
30849       case REVERSE:
30850         jj_consume_token(REVERSE);
30851         break;
30852       case RIGHT:
30853         jj_consume_token(RIGHT);
30854         break;
30855       case ROLLBACK:
30856         jj_consume_token(ROLLBACK);
30857         break;
30858       case ROW:
30859         jj_consume_token(ROW);
30860         break;
30861       case ROWID:
30862         jj_consume_token(ROWID);
30863         break;
30864       case ROWNUM:
30865         jj_consume_token(ROWNUM);
30866         break;
30867       case ROWS:
30868         jj_consume_token(ROWS);
30869         break;
30870       case SAVE:
30871         jj_consume_token(SAVE);
30872         break;
30873       case SAVEPOINT:
30874         jj_consume_token(SAVEPOINT);
30875         break;
30876       case SCHEMA:
30877         jj_consume_token(SCHEMA);
30878         break;
30879       case SECOND:
30880         jj_consume_token(SECOND);
30881         break;
30882       case SELF:
30883         jj_consume_token(SELF);
30884         break;
30885       case SERVERERROR:
30886         jj_consume_token(SERVERERROR);
30887         break;
30888       case SESSIONTIMEZONE:
30889         jj_consume_token(SESSIONTIMEZONE);
30890         break;
30891       case SET:
30892         jj_consume_token(SET);
30893         break;
30894       case SHARED:
30895         jj_consume_token(SHARED);
30896         break;
30897       case SHUTDOWN:
30898         jj_consume_token(SHUTDOWN);
30899         break;
30900       case SPACE:
30901         jj_consume_token(SPACE);
30902         break;
30903       case STARTUP:
30904         jj_consume_token(STARTUP);
30905         break;
30906       case STATEMENT:
30907         jj_consume_token(STATEMENT);
30908         break;
30909       case STATIC:
30910         jj_consume_token(STATIC);
30911         break;
30912       case STATISTICS:
30913         jj_consume_token(STATISTICS);
30914         break;
30915       case STRUCT:
30916         jj_consume_token(STRUCT);
30917         break;
30918       case SUBMULTISET:
30919         jj_consume_token(SUBMULTISET);
30920         break;
30921       case SUBSTITUTABLE:
30922         jj_consume_token(SUBSTITUTABLE);
30923         break;
30924       case SUBTYPE:
30925         jj_consume_token(SUBTYPE);
30926         break;
30927       case SUCCESSFUL:
30928         jj_consume_token(SUCCESSFUL);
30929         break;
30930       case SUSPEND:
30931         jj_consume_token(SUSPEND);
30932         break;
30933       case TDO:
30934         jj_consume_token(TDO);
30935         break;
30936       case TEMPORARY:
30937         jj_consume_token(TEMPORARY);
30938         break;
30939       case TIME:
30940         jj_consume_token(TIME);
30941         break;
30942       case TIMESTAMP:
30943         jj_consume_token(TIMESTAMP);
30944         break;
30945       case TIMEZONE_ABBR:
30946         jj_consume_token(TIMEZONE_ABBR);
30947         break;
30948       case TIMEZONE_HOUR:
30949         jj_consume_token(TIMEZONE_HOUR);
30950         break;
30951       case TIMEZONE_MINUTE:
30952         jj_consume_token(TIMEZONE_MINUTE);
30953         break;
30954       case TIMEZONE_REGION:
30955         jj_consume_token(TIMEZONE_REGION);
30956         break;
30957       case TRAILING:
30958         jj_consume_token(TRAILING);
30959         break;
30960       case TRANSACTION:
30961         jj_consume_token(TRANSACTION);
30962         break;
30963       case TREAT:
30964         jj_consume_token(TREAT);
30965         break;
30966       case TRIM:
30967         jj_consume_token(TRIM);
30968         break;
30969       case TRUNCATE:
30970         jj_consume_token(TRUNCATE);
30971         break;
30972       case UNDEFINE:
30973         jj_consume_token(UNDEFINE);
30974         break;
30975       case UNDER:
30976         jj_consume_token(UNDER);
30977         break;
30978       case UROWID:
30979         jj_consume_token(UROWID);
30980         break;
30981       case USER:
30982         jj_consume_token(USER);
30983         break;
30984       case USING:
30985         jj_consume_token(USING);
30986         break;
30987       case VARRAY:
30988         jj_consume_token(VARRAY);
30989         break;
30990       case VARIABLE:
30991         jj_consume_token(VARIABLE);
30992         break;
30993       case VARYING:
30994         jj_consume_token(VARYING);
30995         break;
30996       case WHENEVER:
30997         jj_consume_token(WHENEVER);
30998         break;
30999       case YEAR:
31000         jj_consume_token(YEAR);
31001         break;
31002       case YES:
31003         jj_consume_token(YES);
31004         break;
31005       case ZONE:
31006         jj_consume_token(ZONE);
31007         break;
31008       case SHOW:
31009         jj_consume_token(SHOW);
31010         break;
31011       case WRAPPED:
31012         jj_consume_token(WRAPPED);
31013         break;
31014       case SYS_REFCURSOR:
31015         jj_consume_token(SYS_REFCURSOR);
31016         break;
31017       case EDITIONABLE:
31018         jj_consume_token(EDITIONABLE);
31019         break;
31020       case NONEDITIONABLE:
31021         jj_consume_token(NONEDITIONABLE);
31022         break;
31023       case ACCESSIBLE:
31024         jj_consume_token(ACCESSIBLE);
31025         break;
31026       case NULLIF:
31027         jj_consume_token(NULLIF);
31028         break;
31029       case RENAME:
31030         jj_consume_token(RENAME);
31031         break;
31032       case RELEASE:
31033         jj_consume_token(RELEASE);
31034         break;
31035       case INLINE:
31036         jj_consume_token(INLINE);
31037         break;
31038       default:
31039         jj_la1[454] = jj_gen;
31040         jj_consume_token(-1);
31041         throw new ParseException();
31042       }
31043   jjtree.closeNodeScope(jjtn000, true);
31044   jjtc000 = false;
31045   jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31046     } finally {
31047   if (jjtc000) {
31048     jjtree.closeNodeScope(jjtn000, true);
31049   }
31050     }
31051     throw new Error("Missing return statement in function");
31052   }
31053 
31054 //SRT 2011-04-17 - END  */
31055 /**
31056  * 2006-05-20 - Matthias Hendler - added &lt;OLD&gt; and &lt;PARENT&gt;
31057  */
31058   final public ASTID ID() throws ParseException {
31059              /*@bgen(jjtree) ID */
31060   ASTID jjtn000 = new ASTID(this, JJTID);
31061   boolean jjtc000 = true;
31062   jjtree.openNodeScope(jjtn000);
31063     try {
31064       switch (jj_nt.kind) {
31065       case IDENTIFIER:
31066         jj_consume_token(IDENTIFIER);
31067         break;
31068       case QUOTED_LITERAL:
31069         jj_consume_token(QUOTED_LITERAL);
31070         break;
31071       case DEFINER:
31072       case CURRENT_USER:
31073       case LANGUAGE:
31074       case INLINE:
31075       case ADD:
31076       case AGGREGATE:
31077       case AT:
31078       case ATTRIBUTE:
31079       case AUTHID:
31080       case BULK:
31081       case BYTE:
31082       case CASCADE:
31083       case CLOSE:
31084       case COALESCE:
31085       case COLLECT:
31086       case COLUMN:
31087       case COMMENT:
31088       case COMMIT:
31089       case CONSTRUCTOR:
31090       case CONTINUE:
31091       case CONVERT:
31092       case CURRENT:
31093       case CURSOR:
31094       case DATA:
31095       case DAY:
31096       case DISABLE:
31097       case EDITIONABLE:
31098       case ELEMENT:
31099       case ENABLE:
31100       case ESCAPE:
31101       case EXCEPT:
31102       case EXCEPTIONS:
31103       case EXIT:
31104       case EXTERNAL:
31105       case EXTENDS:
31106       case EXTRACT:
31107       case FALSE:
31108       case FINAL:
31109       case FORCE:
31110       case FUNCTION:
31111       case GLOBAL:
31112       case HASH:
31113       case HEAP:
31114       case HOUR:
31115       case IMMEDIATE:
31116       case INDICES:
31117       case INDEXTYPE:
31118       case INDICATOR:
31119       case INSTANTIABLE:
31120       case INTERVAL:
31121       case INVALIDATE:
31122       case ISOLATION:
31123       case JAVA:
31124       case LEVEL:
31125       case LIMIT:
31126       case MAP:
31127       case MAX:
31128       case MEMBER:
31129       case MERGE:
31130       case MIN:
31131       case MINUTE:
31132       case MLSLABEL:
31133       case MODIFY:
31134       case MONTH:
31135       case NATURAL:
31136       case NEW:
31137       case NO:
31138       case NONEDITIONABLE:
31139       case NULLIF:
31140       case OBJECT:
31141       case OID:
31142       case OPAQUE:
31143       case OPEN:
31144       case ORGANIZATION:
31145       case OTHERS:
31146       case OVERRIDING:
31147       case PACKAGE:
31148       case PARTITION:
31149       case PRESERVE:
31150       case PROCEDURE:
31151       case RANGE:
31152       case REAL:
31153       case RECORD:
31154       case REF:
31155       case RELEASE:
31156       case RELIES_ON:
31157       case RENAME:
31158       case RESULT:
31159       case RETURN:
31160       case RETURNING:
31161       case REVERSE:
31162       case ROLLBACK:
31163       case ROW:
31164       case ROWS:
31165       case ROWID:
31166       case ROWNUM:
31167       case SAVE:
31168       case SAVEPOINT:
31169       case SECOND:
31170       case SELF:
31171       case SET:
31172       case SPACE:
31173       case STATIC:
31174       case SUBTYPE:
31175       case SUBSTITUTABLE:
31176       case SUCCESSFUL:
31177       case SYS_REFCURSOR:
31178       case TEMPORARY:
31179       case TIME:
31180       case TIMESTAMP:
31181       case TIMEZONE_REGION:
31182       case TIMEZONE_ABBR:
31183       case TIMEZONE_MINUTE:
31184       case TIMEZONE_HOUR:
31185       case TRANSACTION:
31186       case TRUE:
31187       case UNDER:
31188       case USING:
31189       case YES:
31190       case SHOW:
31191       case A:
31192       case DOUBLE:
31193       case DEC:
31194       case PRECISION:
31195       case NUMERIC:
31196       case NCHAR:
31197       case NVARCHAR2:
31198       case UROWID:
31199       case VARRAY:
31200       case VARYING:
31201       case BFILE:
31202       case BLOB:
31203       case CLOB:
31204       case NCLOB:
31205       case YEAR:
31206       case LOCAL:
31207       case ZONE:
31208       case CHARACTER:
31209       case AFTER:
31210       case BEFORE:
31211       case OLD:
31212       case PARENT:
31213       case ANALYZE:
31214       case ASSOCIATE:
31215       case AUDIT:
31216       case COMPOUND:
31217       case DATABASE:
31218       case CALL:
31219       case DDL:
31220       case DISASSOCIATE:
31221       case EACH:
31222       case FOLLOWS:
31223       case LOGOFF:
31224       case LOGON:
31225       case NESTED:
31226       case NOAUDIT:
31227       case SCHEMA:
31228       case SERVERERROR:
31229       case SHUTDOWN:
31230       case STARTUP:
31231       case STATEMENT:
31232       case STATISTICS:
31233       case SUSPEND:
31234       case TRUNCATE:
31235       case WRAPPED:
31236       case LIBRARY:
31237       case NAME:
31238       case STRUCT:
31239       case CONTEXT:
31240       case PARAMETERS:
31241       case LENGTH:
31242       case TDO:
31243       case MAXLEN:
31244       case CHARSETID:
31245       case CHARSETFORM:
31246       case ACCEPT:
31247       case ACCESSIBLE:
31248       case COPY:
31249       case DEFINE:
31250       case DISCONNECT:
31251       case HOST:
31252       case PRINT:
31253       case QUIT:
31254       case REMARK:
31255       case UNDEFINE:
31256       case VARIABLE:
31257       case WHENEVER:
31258       case ATTACH:
31259       case CAST:
31260       case TREAT:
31261       case TRIM:
31262       case LEFT:
31263       case RIGHT:
31264       case BOTH:
31265       case EMPTY:
31266       case MULTISET:
31267       case SUBMULTISET:
31268       case LEADING:
31269       case TRAILING:
31270       case CHAR_CS:
31271       case NCHAR_CS:
31272       case DBTIMEZONE:
31273       case SESSIONTIMEZONE:
31274       case AUTHENTICATED:
31275       case LINK:
31276       case SHARED:
31277       case DIRECTORY:
31278       case USER:
31279         KEYWORD_UNRESERVED();
31280         break;
31281       case REPLACE:
31282         jj_consume_token(REPLACE);
31283         break;
31284       case SERIALLY_REUSABLE:
31285         jj_consume_token(SERIALLY_REUSABLE);
31286         break;
31287       case RESTRICT_REFERENCES:
31288         jj_consume_token(RESTRICT_REFERENCES);
31289         break;
31290       case EXCEPTION_INIT:
31291         jj_consume_token(EXCEPTION_INIT);
31292         break;
31293       case AUTONOMOUS_TRANSACTION:
31294         jj_consume_token(AUTONOMOUS_TRANSACTION);
31295         break;
31296       case ALL:
31297         jj_consume_token(ALL);
31298         break;
31299       case ALTER:
31300         jj_consume_token(ALTER);
31301         break;
31302       case AND:
31303         jj_consume_token(AND);
31304         break;
31305       case ANY:
31306         jj_consume_token(ANY);
31307         break;
31308       case ARRAY:
31309         jj_consume_token(ARRAY);
31310         break;
31311       case AS:
31312         jj_consume_token(AS);
31313         break;
31314       case ASC:
31315         jj_consume_token(ASC);
31316         break;
31317       case AVG:
31318         jj_consume_token(AVG);
31319         break;
31320       case BETWEEN:
31321         jj_consume_token(BETWEEN);
31322         break;
31323       case BINARY_INTEGER:
31324         jj_consume_token(BINARY_INTEGER);
31325         break;
31326       case BODY:
31327         jj_consume_token(BODY);
31328         break;
31329       case BOOLEAN:
31330         jj_consume_token(BOOLEAN);
31331         break;
31332       case BY:
31333         jj_consume_token(BY);
31334         break;
31335       case CASE:
31336         jj_consume_token(CASE);
31337         break;
31338       case CHAR:
31339         jj_consume_token(CHAR);
31340         break;
31341       case CHAR_BASE:
31342         jj_consume_token(CHAR_BASE);
31343         break;
31344       case CHECK:
31345         jj_consume_token(CHECK);
31346         break;
31347       case CLUSTER:
31348         jj_consume_token(CLUSTER);
31349         break;
31350       case COMPRESS:
31351         jj_consume_token(COMPRESS);
31352         break;
31353       case CONNECT:
31354         jj_consume_token(CONNECT);
31355         break;
31356       case CONSTANT:
31357         jj_consume_token(CONSTANT);
31358         break;
31359       case CREATE:
31360         jj_consume_token(CREATE);
31361         break;
31362       case CURRVAL:
31363         jj_consume_token(CURRVAL);
31364         break;
31365       case DATE:
31366         jj_consume_token(DATE);
31367         break;
31368       case DECLARE:
31369         jj_consume_token(DECLARE);
31370         break;
31371       case DECIMAL:
31372         jj_consume_token(DECIMAL);
31373         break;
31374       case _DEFAULT:
31375         jj_consume_token(_DEFAULT);
31376         break;
31377       case DELETE:
31378         jj_consume_token(DELETE);
31379         break;
31380       case DESC:
31381         jj_consume_token(DESC);
31382         break;
31383       case DISTINCT:
31384         jj_consume_token(DISTINCT);
31385         break;
31386       case DO:
31387         jj_consume_token(DO);
31388         break;
31389       case DROP:
31390         jj_consume_token(DROP);
31391         break;
31392       case ELSE:
31393         jj_consume_token(ELSE);
31394         break;
31395       case ELSIF:
31396         jj_consume_token(ELSIF);
31397         break;
31398       case EXCEPTION:
31399         jj_consume_token(EXCEPTION);
31400         break;
31401       case EXCLUSIVE:
31402         jj_consume_token(EXCLUSIVE);
31403         break;
31404       case EXECUTE:
31405         jj_consume_token(EXECUTE);
31406         break;
31407       case EXISTS:
31408         jj_consume_token(EXISTS);
31409         break;
31410       case FETCH:
31411         jj_consume_token(FETCH);
31412         break;
31413       case FLOAT:
31414         jj_consume_token(FLOAT);
31415         break;
31416       case FOR:
31417         jj_consume_token(FOR);
31418         break;
31419       case FORALL:
31420         jj_consume_token(FORALL);
31421         break;
31422       case FROM:
31423         jj_consume_token(FROM);
31424         break;
31425       case GOTO:
31426         jj_consume_token(GOTO);
31427         break;
31428       case GROUP:
31429         jj_consume_token(GROUP);
31430         break;
31431       case HAVING:
31432         jj_consume_token(HAVING);
31433         break;
31434       case IF:
31435         jj_consume_token(IF);
31436         break;
31437       case IN:
31438         jj_consume_token(IN);
31439         break;
31440       case INDEX:
31441         jj_consume_token(INDEX);
31442         break;
31443       case INSERT:
31444         jj_consume_token(INSERT);
31445         break;
31446       case INTEGER:
31447         jj_consume_token(INTEGER);
31448         break;
31449       case INTERFACE:
31450         jj_consume_token(INTERFACE);
31451         break;
31452       case INTERSECT:
31453         jj_consume_token(INTERSECT);
31454         break;
31455       case INTO:
31456         jj_consume_token(INTO);
31457         break;
31458       case IS:
31459         jj_consume_token(IS);
31460         break;
31461       case LIKE:
31462         jj_consume_token(LIKE);
31463         break;
31464       case LIMITED:
31465         jj_consume_token(LIMITED);
31466         break;
31467       case LOCK:
31468         jj_consume_token(LOCK);
31469         break;
31470       case LONG:
31471         jj_consume_token(LONG);
31472         break;
31473       case LOOP:
31474         jj_consume_token(LOOP);
31475         break;
31476       case MINUS:
31477         jj_consume_token(MINUS);
31478         break;
31479       case MOD:
31480         jj_consume_token(MOD);
31481         break;
31482       case MODE:
31483         jj_consume_token(MODE);
31484         break;
31485       case NATURALN:
31486         jj_consume_token(NATURALN);
31487         break;
31488       case NEXTVAL:
31489         jj_consume_token(NEXTVAL);
31490         break;
31491       case NOCOPY:
31492         jj_consume_token(NOCOPY);
31493         break;
31494       case NOT:
31495         jj_consume_token(NOT);
31496         break;
31497       case NOWAIT:
31498         jj_consume_token(NOWAIT);
31499         break;
31500       case NULL:
31501         jj_consume_token(NULL);
31502         break;
31503       case NUMBER:
31504         jj_consume_token(NUMBER);
31505         break;
31506       case NUMBER_BASE:
31507         jj_consume_token(NUMBER_BASE);
31508         break;
31509       case OCIROWID:
31510         jj_consume_token(OCIROWID);
31511         break;
31512       case OF:
31513         jj_consume_token(OF);
31514         break;
31515       case ON:
31516         jj_consume_token(ON);
31517         break;
31518       case BFILE_BASE:
31519         jj_consume_token(BFILE_BASE);
31520         break;
31521       case BLOB_BASE:
31522         jj_consume_token(BLOB_BASE);
31523         break;
31524       case CLOB_BASE:
31525         jj_consume_token(CLOB_BASE);
31526         break;
31527       case DATE_BASE:
31528         jj_consume_token(DATE_BASE);
31529         break;
31530       case OPERATOR:
31531         jj_consume_token(OPERATOR);
31532         break;
31533       case OPTION:
31534         jj_consume_token(OPTION);
31535         break;
31536       case OR:
31537         jj_consume_token(OR);
31538         break;
31539       case ORDER:
31540         jj_consume_token(ORDER);
31541         break;
31542       case OUT:
31543         jj_consume_token(OUT);
31544         break;
31545       case PCTFREE:
31546         jj_consume_token(PCTFREE);
31547         break;
31548       case PLS_INTEGER:
31549         jj_consume_token(PLS_INTEGER);
31550         break;
31551       case POSITIVE:
31552         jj_consume_token(POSITIVE);
31553         break;
31554       case POSITIVEN:
31555         jj_consume_token(POSITIVEN);
31556         break;
31557       case PRIOR:
31558         jj_consume_token(PRIOR);
31559         break;
31560       case PRIVATE:
31561         jj_consume_token(PRIVATE);
31562         break;
31563       case PROMPT:
31564         jj_consume_token(PROMPT);
31565         break;
31566       case PUBLIC:
31567         jj_consume_token(PUBLIC);
31568         break;
31569       case RAISE:
31570         jj_consume_token(RAISE);
31571         break;
31572       case RAW:
31573         jj_consume_token(RAW);
31574         break;
31575       case ROWTYPE:
31576         jj_consume_token(ROWTYPE);
31577         break;
31578       case SELECT:
31579         jj_consume_token(SELECT);
31580         break;
31581       case SEPARATE:
31582         jj_consume_token(SEPARATE);
31583         break;
31584       case SHARE:
31585         jj_consume_token(SHARE);
31586         break;
31587       case SMALLINT:
31588         jj_consume_token(SMALLINT);
31589         break;
31590       case SQL:
31591         jj_consume_token(SQL);
31592         break;
31593       case SQLCODE:
31594         jj_consume_token(SQLCODE);
31595         break;
31596       case SQLERRM:
31597         jj_consume_token(SQLERRM);
31598         break;
31599       case START:
31600         jj_consume_token(START);
31601         break;
31602       case STDDEV:
31603         jj_consume_token(STDDEV);
31604         break;
31605       case SUM:
31606         jj_consume_token(SUM);
31607         break;
31608       case SYNONYM:
31609         jj_consume_token(SYNONYM);
31610         break;
31611       case SYSDATE:
31612         jj_consume_token(SYSDATE);
31613         break;
31614       case TABLE:
31615         jj_consume_token(TABLE);
31616         break;
31617       case THEN:
31618         jj_consume_token(THEN);
31619         break;
31620       case TO:
31621         jj_consume_token(TO);
31622         break;
31623       case TRIGGER:
31624         jj_consume_token(TRIGGER);
31625         break;
31626       case TYPE:
31627         jj_consume_token(TYPE);
31628         break;
31629       case UI:
31630         jj_consume_token(UI);
31631         break;
31632       case UPDATE:
31633         jj_consume_token(UPDATE);
31634         break;
31635       case VARCHAR:
31636         jj_consume_token(VARCHAR);
31637         break;
31638       case VARCHAR2:
31639         jj_consume_token(VARCHAR2);
31640         break;
31641       case INT:
31642         jj_consume_token(INT);
31643         break;
31644       case SIGNTYPE:
31645         jj_consume_token(SIGNTYPE);
31646         break;
31647       case STRING:
31648         jj_consume_token(STRING);
31649         break;
31650       case WITH:
31651         jj_consume_token(WITH);
31652         break;
31653       case WHILE:
31654         jj_consume_token(WHILE);
31655         break;
31656       case JAVA_INTERFACE_CLASS:
31657         jj_consume_token(JAVA_INTERFACE_CLASS);
31658         break;
31659       case SQLDATA_CLASS:
31660         jj_consume_token(SQLDATA_CLASS);
31661         break;
31662       case CUSTOMDATUM_CLASS:
31663         jj_consume_token(CUSTOMDATUM_CLASS);
31664         break;
31665       case ORADATA_CLASS:
31666         jj_consume_token(ORADATA_CLASS);
31667         break;
31668       default:
31669         jj_la1[455] = jj_gen;
31670         jj_consume_token(-1);
31671         throw new ParseException();
31672       }
31673           jjtree.closeNodeScope(jjtn000, true);
31674           jjtc000 = false;
31675           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31676     } catch (Throwable jjte000) {
31677           if (jjtc000) {
31678             jjtree.clearNodeScope(jjtn000);
31679             jjtc000 = false;
31680           } else {
31681             jjtree.popNode();
31682           }
31683           if (jjte000 instanceof RuntimeException) {
31684             {if (true) throw (RuntimeException)jjte000;}
31685           }
31686           if (jjte000 instanceof ParseException) {
31687             {if (true) throw (ParseException)jjte000;}
31688           }
31689           {if (true) throw (Error)jjte000;}
31690     } finally {
31691           if (jjtc000) {
31692             jjtree.closeNodeScope(jjtn000, true);
31693           }
31694     }
31695     throw new Error("Missing return statement in function");
31696   }
31697 
31698 /**
31699  * 2006-05-20 - Matthias Hendler - added &lt;OLD&gt;, &lt;NEW&gt;, &lt;LOOP&gt;, &lt;INT&gt;
31700  */
31701   final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31702                                    /*@bgen(jjtree) UnqualifiedID */
31703   ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
31704   boolean jjtc000 = true;
31705   jjtree.openNodeScope(jjtn000);
31706     try {
31707       switch (jj_nt.kind) {
31708       case IDENTIFIER:
31709         jj_consume_token(IDENTIFIER);
31710         break;
31711       case QUOTED_LITERAL:
31712         jj_consume_token(QUOTED_LITERAL);
31713         break;
31714       case DEFINER:
31715       case CURRENT_USER:
31716       case LANGUAGE:
31717       case INLINE:
31718       case ADD:
31719       case AGGREGATE:
31720       case AT:
31721       case ATTRIBUTE:
31722       case AUTHID:
31723       case BULK:
31724       case BYTE:
31725       case CASCADE:
31726       case CLOSE:
31727       case COALESCE:
31728       case COLLECT:
31729       case COLUMN:
31730       case COMMENT:
31731       case COMMIT:
31732       case CONSTRUCTOR:
31733       case CONTINUE:
31734       case CONVERT:
31735       case CURRENT:
31736       case CURSOR:
31737       case DATA:
31738       case DAY:
31739       case DISABLE:
31740       case EDITIONABLE:
31741       case ELEMENT:
31742       case ENABLE:
31743       case ESCAPE:
31744       case EXCEPT:
31745       case EXCEPTIONS:
31746       case EXIT:
31747       case EXTERNAL:
31748       case EXTENDS:
31749       case EXTRACT:
31750       case FALSE:
31751       case FINAL:
31752       case FORCE:
31753       case FUNCTION:
31754       case GLOBAL:
31755       case HASH:
31756       case HEAP:
31757       case HOUR:
31758       case IMMEDIATE:
31759       case INDICES:
31760       case INDEXTYPE:
31761       case INDICATOR:
31762       case INSTANTIABLE:
31763       case INTERVAL:
31764       case INVALIDATE:
31765       case ISOLATION:
31766       case JAVA:
31767       case LEVEL:
31768       case LIMIT:
31769       case MAP:
31770       case MAX:
31771       case MEMBER:
31772       case MERGE:
31773       case MIN:
31774       case MINUTE:
31775       case MLSLABEL:
31776       case MODIFY:
31777       case MONTH:
31778       case NATURAL:
31779       case NEW:
31780       case NO:
31781       case NONEDITIONABLE:
31782       case NULLIF:
31783       case OBJECT:
31784       case OID:
31785       case OPAQUE:
31786       case OPEN:
31787       case ORGANIZATION:
31788       case OTHERS:
31789       case OVERRIDING:
31790       case PACKAGE:
31791       case PARTITION:
31792       case PRESERVE:
31793       case PROCEDURE:
31794       case RANGE:
31795       case REAL:
31796       case RECORD:
31797       case REF:
31798       case RELEASE:
31799       case RELIES_ON:
31800       case RENAME:
31801       case RESULT:
31802       case RETURN:
31803       case RETURNING:
31804       case REVERSE:
31805       case ROLLBACK:
31806       case ROW:
31807       case ROWS:
31808       case ROWID:
31809       case ROWNUM:
31810       case SAVE:
31811       case SAVEPOINT:
31812       case SECOND:
31813       case SELF:
31814       case SET:
31815       case SPACE:
31816       case STATIC:
31817       case SUBTYPE:
31818       case SUBSTITUTABLE:
31819       case SUCCESSFUL:
31820       case SYS_REFCURSOR:
31821       case TEMPORARY:
31822       case TIME:
31823       case TIMESTAMP:
31824       case TIMEZONE_REGION:
31825       case TIMEZONE_ABBR:
31826       case TIMEZONE_MINUTE:
31827       case TIMEZONE_HOUR:
31828       case TRANSACTION:
31829       case TRUE:
31830       case UNDER:
31831       case USING:
31832       case YES:
31833       case SHOW:
31834       case A:
31835       case DOUBLE:
31836       case DEC:
31837       case PRECISION:
31838       case NUMERIC:
31839       case NCHAR:
31840       case NVARCHAR2:
31841       case UROWID:
31842       case VARRAY:
31843       case VARYING:
31844       case BFILE:
31845       case BLOB:
31846       case CLOB:
31847       case NCLOB:
31848       case YEAR:
31849       case LOCAL:
31850       case ZONE:
31851       case CHARACTER:
31852       case AFTER:
31853       case BEFORE:
31854       case OLD:
31855       case PARENT:
31856       case ANALYZE:
31857       case ASSOCIATE:
31858       case AUDIT:
31859       case COMPOUND:
31860       case DATABASE:
31861       case CALL:
31862       case DDL:
31863       case DISASSOCIATE:
31864       case EACH:
31865       case FOLLOWS:
31866       case LOGOFF:
31867       case LOGON:
31868       case NESTED:
31869       case NOAUDIT:
31870       case SCHEMA:
31871       case SERVERERROR:
31872       case SHUTDOWN:
31873       case STARTUP:
31874       case STATEMENT:
31875       case STATISTICS:
31876       case SUSPEND:
31877       case TRUNCATE:
31878       case WRAPPED:
31879       case LIBRARY:
31880       case NAME:
31881       case STRUCT:
31882       case CONTEXT:
31883       case PARAMETERS:
31884       case LENGTH:
31885       case TDO:
31886       case MAXLEN:
31887       case CHARSETID:
31888       case CHARSETFORM:
31889       case ACCEPT:
31890       case ACCESSIBLE:
31891       case COPY:
31892       case DEFINE:
31893       case DISCONNECT:
31894       case HOST:
31895       case PRINT:
31896       case QUIT:
31897       case REMARK:
31898       case UNDEFINE:
31899       case VARIABLE:
31900       case WHENEVER:
31901       case ATTACH:
31902       case CAST:
31903       case TREAT:
31904       case TRIM:
31905       case LEFT:
31906       case RIGHT:
31907       case BOTH:
31908       case EMPTY:
31909       case MULTISET:
31910       case SUBMULTISET:
31911       case LEADING:
31912       case TRAILING:
31913       case CHAR_CS:
31914       case NCHAR_CS:
31915       case DBTIMEZONE:
31916       case SESSIONTIMEZONE:
31917       case AUTHENTICATED:
31918       case LINK:
31919       case SHARED:
31920       case DIRECTORY:
31921       case USER:
31922         KEYWORD_UNRESERVED();
31923         break;
31924       case BODY:
31925         jj_consume_token(BODY);
31926         break;
31927       case MOD:
31928         jj_consume_token(MOD);
31929         break;
31930       case OPERATOR:
31931         jj_consume_token(OPERATOR);
31932         break;
31933       case PRIVATE:
31934         jj_consume_token(PRIVATE);
31935         break;
31936       case RAW:
31937         jj_consume_token(RAW);
31938         break;
31939       case REPLACE:
31940         jj_consume_token(REPLACE);
31941         break;
31942       case STRING:
31943         jj_consume_token(STRING);
31944         break;
31945       case SQL:
31946         jj_consume_token(SQL);
31947         break;
31948       case SQLCODE:
31949         jj_consume_token(SQLCODE);
31950         break;
31951       case SQLERRM:
31952         jj_consume_token(SQLERRM);
31953         break;
31954       case SYSDATE:
31955         jj_consume_token(SYSDATE);
31956         break;
31957       case TYPE:
31958         jj_consume_token(TYPE);
31959         break;
31960       case LOOP:
31961         jj_consume_token(LOOP);
31962         break;
31963       case INT:
31964         jj_consume_token(INT);
31965         break;
31966       case ARRAY:
31967         jj_consume_token(ARRAY);
31968         break;
31969       default:
31970         jj_la1[456] = jj_gen;
31971         jj_consume_token(-1);
31972         throw new ParseException();
31973       }
31974           jjtree.closeNodeScope(jjtn000, true);
31975           jjtc000 = false;
31976           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31977     } catch (Throwable jjte000) {
31978           if (jjtc000) {
31979             jjtree.clearNodeScope(jjtn000);
31980             jjtc000 = false;
31981           } else {
31982             jjtree.popNode();
31983           }
31984           if (jjte000 instanceof RuntimeException) {
31985             {if (true) throw (RuntimeException)jjte000;}
31986           }
31987           if (jjte000 instanceof ParseException) {
31988             {if (true) throw (ParseException)jjte000;}
31989           }
31990           {if (true) throw (Error)jjte000;}
31991     } finally {
31992           if (jjtc000) {
31993             jjtree.closeNodeScope(jjtn000, true);
31994           }
31995     }
31996     throw new Error("Missing return statement in function");
31997   }
31998 
31999 /**
32000  * 2006-05-20 - Matthias Hendler - added &lt;LIMIT&gt;
32001  */
32002   final public ASTQualifiedID QualifiedID() throws ParseException {
32003                                /*@bgen(jjtree) QualifiedID */
32004   ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
32005   boolean jjtc000 = true;
32006   jjtree.openNodeScope(jjtn000);
32007     try {
32008       switch (jj_nt.kind) {
32009       case IDENTIFIER:
32010         jj_consume_token(IDENTIFIER);
32011         break;
32012       case QUOTED_LITERAL:
32013         jj_consume_token(QUOTED_LITERAL);
32014         break;
32015       case DEFINER:
32016       case CURRENT_USER:
32017       case LANGUAGE:
32018       case INLINE:
32019       case ADD:
32020       case AGGREGATE:
32021       case AT:
32022       case ATTRIBUTE:
32023       case AUTHID:
32024       case BULK:
32025       case BYTE:
32026       case CASCADE:
32027       case CLOSE:
32028       case COALESCE:
32029       case COLLECT:
32030       case COLUMN:
32031       case COMMENT:
32032       case COMMIT:
32033       case CONSTRUCTOR:
32034       case CONTINUE:
32035       case CONVERT:
32036       case CURRENT:
32037       case CURSOR:
32038       case DATA:
32039       case DAY:
32040       case DISABLE:
32041       case EDITIONABLE:
32042       case ELEMENT:
32043       case ENABLE:
32044       case ESCAPE:
32045       case EXCEPT:
32046       case EXCEPTIONS:
32047       case EXIT:
32048       case EXTERNAL:
32049       case EXTENDS:
32050       case EXTRACT:
32051       case FALSE:
32052       case FINAL:
32053       case FORCE:
32054       case FUNCTION:
32055       case GLOBAL:
32056       case HASH:
32057       case HEAP:
32058       case HOUR:
32059       case IMMEDIATE:
32060       case INDICES:
32061       case INDEXTYPE:
32062       case INDICATOR:
32063       case INSTANTIABLE:
32064       case INTERVAL:
32065       case INVALIDATE:
32066       case ISOLATION:
32067       case JAVA:
32068       case LEVEL:
32069       case LIMIT:
32070       case MAP:
32071       case MAX:
32072       case MEMBER:
32073       case MERGE:
32074       case MIN:
32075       case MINUTE:
32076       case MLSLABEL:
32077       case MODIFY:
32078       case MONTH:
32079       case NATURAL:
32080       case NEW:
32081       case NO:
32082       case NONEDITIONABLE:
32083       case NULLIF:
32084       case OBJECT:
32085       case OID:
32086       case OPAQUE:
32087       case OPEN:
32088       case ORGANIZATION:
32089       case OTHERS:
32090       case OVERRIDING:
32091       case PACKAGE:
32092       case PARTITION:
32093       case PRESERVE:
32094       case PROCEDURE:
32095       case RANGE:
32096       case REAL:
32097       case RECORD:
32098       case REF:
32099       case RELEASE:
32100       case RELIES_ON:
32101       case RENAME:
32102       case RESULT:
32103       case RETURN:
32104       case RETURNING:
32105       case REVERSE:
32106       case ROLLBACK:
32107       case ROW:
32108       case ROWS:
32109       case ROWID:
32110       case ROWNUM:
32111       case SAVE:
32112       case SAVEPOINT:
32113       case SECOND:
32114       case SELF:
32115       case SET:
32116       case SPACE:
32117       case STATIC:
32118       case SUBTYPE:
32119       case SUBSTITUTABLE:
32120       case SUCCESSFUL:
32121       case SYS_REFCURSOR:
32122       case TEMPORARY:
32123       case TIME:
32124       case TIMESTAMP:
32125       case TIMEZONE_REGION:
32126       case TIMEZONE_ABBR:
32127       case TIMEZONE_MINUTE:
32128       case TIMEZONE_HOUR:
32129       case TRANSACTION:
32130       case TRUE:
32131       case UNDER:
32132       case USING:
32133       case YES:
32134       case SHOW:
32135       case A:
32136       case DOUBLE:
32137       case DEC:
32138       case PRECISION:
32139       case NUMERIC:
32140       case NCHAR:
32141       case NVARCHAR2:
32142       case UROWID:
32143       case VARRAY:
32144       case VARYING:
32145       case BFILE:
32146       case BLOB:
32147       case CLOB:
32148       case NCLOB:
32149       case YEAR:
32150       case LOCAL:
32151       case ZONE:
32152       case CHARACTER:
32153       case AFTER:
32154       case BEFORE:
32155       case OLD:
32156       case PARENT:
32157       case ANALYZE:
32158       case ASSOCIATE:
32159       case AUDIT:
32160       case COMPOUND:
32161       case DATABASE:
32162       case CALL:
32163       case DDL:
32164       case DISASSOCIATE:
32165       case EACH:
32166       case FOLLOWS:
32167       case LOGOFF:
32168       case LOGON:
32169       case NESTED:
32170       case NOAUDIT:
32171       case SCHEMA:
32172       case SERVERERROR:
32173       case SHUTDOWN:
32174       case STARTUP:
32175       case STATEMENT:
32176       case STATISTICS:
32177       case SUSPEND:
32178       case TRUNCATE:
32179       case WRAPPED:
32180       case LIBRARY:
32181       case NAME:
32182       case STRUCT:
32183       case CONTEXT:
32184       case PARAMETERS:
32185       case LENGTH:
32186       case TDO:
32187       case MAXLEN:
32188       case CHARSETID:
32189       case CHARSETFORM:
32190       case ACCEPT:
32191       case ACCESSIBLE:
32192       case COPY:
32193       case DEFINE:
32194       case DISCONNECT:
32195       case HOST:
32196       case PRINT:
32197       case QUIT:
32198       case REMARK:
32199       case UNDEFINE:
32200       case VARIABLE:
32201       case WHENEVER:
32202       case ATTACH:
32203       case CAST:
32204       case TREAT:
32205       case TRIM:
32206       case LEFT:
32207       case RIGHT:
32208       case BOTH:
32209       case EMPTY:
32210       case MULTISET:
32211       case SUBMULTISET:
32212       case LEADING:
32213       case TRAILING:
32214       case CHAR_CS:
32215       case NCHAR_CS:
32216       case DBTIMEZONE:
32217       case SESSIONTIMEZONE:
32218       case AUTHENTICATED:
32219       case LINK:
32220       case SHARED:
32221       case DIRECTORY:
32222       case USER:
32223         KEYWORD_UNRESERVED();
32224         break;
32225       case REPLACE:
32226         jj_consume_token(REPLACE);
32227         break;
32228       case SERIALLY_REUSABLE:
32229         jj_consume_token(SERIALLY_REUSABLE);
32230         break;
32231       case RESTRICT_REFERENCES:
32232         jj_consume_token(RESTRICT_REFERENCES);
32233         break;
32234       case EXCEPTION_INIT:
32235         jj_consume_token(EXCEPTION_INIT);
32236         break;
32237       case AUTONOMOUS_TRANSACTION:
32238         jj_consume_token(AUTONOMOUS_TRANSACTION);
32239         break;
32240       case ARRAY:
32241         jj_consume_token(ARRAY);
32242         break;
32243       case AVG:
32244         jj_consume_token(AVG);
32245         break;
32246       case BINARY_INTEGER:
32247         jj_consume_token(BINARY_INTEGER);
32248         break;
32249       case BODY:
32250         jj_consume_token(BODY);
32251         break;
32252       case BOOLEAN:
32253         jj_consume_token(BOOLEAN);
32254         break;
32255       case CHAR:
32256         jj_consume_token(CHAR);
32257         break;
32258       case CHAR_BASE:
32259         jj_consume_token(CHAR_BASE);
32260         break;
32261       case CONSTANT:
32262         jj_consume_token(CONSTANT);
32263         break;
32264       case CURRVAL:
32265         jj_consume_token(CURRVAL);
32266         break;
32267       case DATE:
32268         jj_consume_token(DATE);
32269         break;
32270       case DECIMAL:
32271         jj_consume_token(DECIMAL);
32272         break;
32273       case DELETE:
32274         jj_consume_token(DELETE);
32275         break;
32276       case DO:
32277         jj_consume_token(DO);
32278         break;
32279       case ELSIF:
32280         jj_consume_token(ELSIF);
32281         break;
32282       case EXECUTE:
32283         jj_consume_token(EXECUTE);
32284         break;
32285       case EXISTS:
32286         jj_consume_token(EXISTS);
32287         break;
32288       case FLOAT:
32289         jj_consume_token(FLOAT);
32290         break;
32291       case FORALL:
32292         jj_consume_token(FORALL);
32293         break;
32294       case INTEGER:
32295         jj_consume_token(INTEGER);
32296         break;
32297       case INTERFACE:
32298         jj_consume_token(INTERFACE);
32299         break;
32300       case LONG:
32301         jj_consume_token(LONG);
32302         break;
32303       case LOOP:
32304         jj_consume_token(LOOP);
32305         break;
32306       case MOD:
32307         jj_consume_token(MOD);
32308         break;
32309       case NATURALN:
32310         jj_consume_token(NATURALN);
32311         break;
32312       case NEXTVAL:
32313         jj_consume_token(NEXTVAL);
32314         break;
32315       case NOCOPY:
32316         jj_consume_token(NOCOPY);
32317         break;
32318       case NUMBER:
32319         jj_consume_token(NUMBER);
32320         break;
32321       case BFILE_BASE:
32322         jj_consume_token(BFILE_BASE);
32323         break;
32324       case BLOB_BASE:
32325         jj_consume_token(BLOB_BASE);
32326         break;
32327       case CLOB_BASE:
32328         jj_consume_token(CLOB_BASE);
32329         break;
32330       case DATE_BASE:
32331         jj_consume_token(DATE_BASE);
32332         break;
32333       case NUMBER_BASE:
32334         jj_consume_token(NUMBER_BASE);
32335         break;
32336       case OCIROWID:
32337         jj_consume_token(OCIROWID);
32338         break;
32339       case OPERATOR:
32340         jj_consume_token(OPERATOR);
32341         break;
32342       case OUT:
32343         jj_consume_token(OUT);
32344         break;
32345       case PLS_INTEGER:
32346         jj_consume_token(PLS_INTEGER);
32347         break;
32348       case POSITIVE:
32349         jj_consume_token(POSITIVE);
32350         break;
32351       case POSITIVEN:
32352         jj_consume_token(POSITIVEN);
32353         break;
32354       case PRAGMA:
32355         jj_consume_token(PRAGMA);
32356         break;
32357       case PRIOR:
32358         jj_consume_token(PRIOR);
32359         break;
32360       case PRIVATE:
32361         jj_consume_token(PRIVATE);
32362         break;
32363       case PROMPT:
32364         jj_consume_token(PROMPT);
32365         break;
32366       case RAISE:
32367         jj_consume_token(RAISE);
32368         break;
32369       case RAW:
32370         jj_consume_token(RAW);
32371         break;
32372       case ROWTYPE:
32373         jj_consume_token(ROWTYPE);
32374         break;
32375       case SEPARATE:
32376         jj_consume_token(SEPARATE);
32377         break;
32378       case SMALLINT:
32379         jj_consume_token(SMALLINT);
32380         break;
32381       case SQLCODE:
32382         jj_consume_token(SQLCODE);
32383         break;
32384       case SQLERRM:
32385         jj_consume_token(SQLERRM);
32386         break;
32387       case STDDEV:
32388         jj_consume_token(STDDEV);
32389         break;
32390       case SUM:
32391         jj_consume_token(SUM);
32392         break;
32393       case SYNONYM:
32394         jj_consume_token(SYNONYM);
32395         break;
32396       case SYSDATE:
32397         jj_consume_token(SYSDATE);
32398         break;
32399       case TRIGGER:
32400         jj_consume_token(TRIGGER);
32401         break;
32402       case TYPE:
32403         jj_consume_token(TYPE);
32404         break;
32405       case UI:
32406         jj_consume_token(UI);
32407         break;
32408       case VARCHAR:
32409         jj_consume_token(VARCHAR);
32410         break;
32411       case VARCHAR2:
32412         jj_consume_token(VARCHAR2);
32413         break;
32414       case INT:
32415         jj_consume_token(INT);
32416         break;
32417       case SIGNTYPE:
32418         jj_consume_token(SIGNTYPE);
32419         break;
32420       case STRING:
32421         jj_consume_token(STRING);
32422         break;
32423       case WHILE:
32424         jj_consume_token(WHILE);
32425         break;
32426       default:
32427         jj_la1[457] = jj_gen;
32428         jj_consume_token(-1);
32429         throw new ParseException();
32430       }
32431           jjtree.closeNodeScope(jjtn000, true);
32432           jjtc000 = false;
32433           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32434     } catch (Throwable jjte000) {
32435           if (jjtc000) {
32436             jjtree.clearNodeScope(jjtn000);
32437             jjtc000 = false;
32438           } else {
32439             jjtree.popNode();
32440           }
32441           if (jjte000 instanceof RuntimeException) {
32442             {if (true) throw (RuntimeException)jjte000;}
32443           }
32444           if (jjte000 instanceof ParseException) {
32445             {if (true) throw (ParseException)jjte000;}
32446           }
32447           {if (true) throw (Error)jjte000;}
32448     } finally {
32449           if (jjtc000) {
32450             jjtree.closeNodeScope(jjtn000, true);
32451           }
32452     }
32453     throw new Error("Missing return statement in function");
32454   }
32455 
32456   final public ASTTypeKeyword TypeKeyword() throws ParseException {
32457                                /*@bgen(jjtree) TypeKeyword */
32458   ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
32459   boolean jjtc000 = true;
32460   jjtree.openNodeScope(jjtn000);
32461     try {
32462       switch (jj_nt.kind) {
32463       case BFILE_BASE:
32464         jj_consume_token(BFILE_BASE);
32465         break;
32466       case BLOB_BASE:
32467         jj_consume_token(BLOB_BASE);
32468         break;
32469       case CLOB_BASE:
32470         jj_consume_token(CLOB_BASE);
32471         break;
32472       case DATE_BASE:
32473         jj_consume_token(DATE_BASE);
32474         break;
32475       case NUMBER_BASE:
32476         jj_consume_token(NUMBER_BASE);
32477         break;
32478       case BOOLEAN:
32479         jj_consume_token(BOOLEAN);
32480         break;
32481       case DATE:
32482         jj_consume_token(DATE);
32483         break;
32484       case NUMBER:
32485         jj_consume_token(NUMBER);
32486         break;
32487       case FLOAT:
32488         jj_consume_token(FLOAT);
32489         break;
32490       case REAL:
32491         jj_consume_token(REAL);
32492         break;
32493       case INTEGER:
32494         jj_consume_token(INTEGER);
32495         break;
32496       case INT:
32497         jj_consume_token(INT);
32498         break;
32499       case SMALLINT:
32500         jj_consume_token(SMALLINT);
32501         break;
32502       case DECIMAL:
32503         jj_consume_token(DECIMAL);
32504         break;
32505       case NUMERIC:
32506         jj_consume_token(NUMERIC);
32507         break;
32508       case DEC:
32509         jj_consume_token(DEC);
32510         break;
32511       case BINARY_INTEGER:
32512         jj_consume_token(BINARY_INTEGER);
32513         break;
32514       case NATURAL:
32515         jj_consume_token(NATURAL);
32516         break;
32517       case NATURALN:
32518         jj_consume_token(NATURALN);
32519         break;
32520       case POSITIVE:
32521         jj_consume_token(POSITIVE);
32522         break;
32523       case POSITIVEN:
32524         jj_consume_token(POSITIVEN);
32525         break;
32526       case SIGNTYPE:
32527         jj_consume_token(SIGNTYPE);
32528         break;
32529       case VARCHAR2:
32530         jj_consume_token(VARCHAR2);
32531         break;
32532       case VARCHAR:
32533         jj_consume_token(VARCHAR);
32534         break;
32535       case STRING:
32536         jj_consume_token(STRING);
32537         break;
32538       case LONG:
32539         jj_consume_token(LONG);
32540         break;
32541       case RAW:
32542         jj_consume_token(RAW);
32543         break;
32544       case ROWID:
32545         jj_consume_token(ROWID);
32546         break;
32547       case CHAR:
32548         jj_consume_token(CHAR);
32549         break;
32550       case CHARACTER:
32551         jj_consume_token(CHARACTER);
32552         break;
32553       case MLSLABEL:
32554         jj_consume_token(MLSLABEL);
32555         break;
32556       case BLOB:
32557         jj_consume_token(BLOB);
32558         break;
32559       case CLOB:
32560         jj_consume_token(CLOB);
32561         break;
32562       case BFILE:
32563         jj_consume_token(BFILE);
32564         break;
32565       case NCHAR:
32566         jj_consume_token(NCHAR);
32567         break;
32568       case NVARCHAR2:
32569         jj_consume_token(NVARCHAR2);
32570         break;
32571       case NCLOB:
32572         jj_consume_token(NCLOB);
32573         break;
32574       case PLS_INTEGER:
32575         jj_consume_token(PLS_INTEGER);
32576         break;
32577       case TIME:
32578         jj_consume_token(TIME);
32579         break;
32580       case TIMESTAMP:
32581         jj_consume_token(TIMESTAMP);
32582         break;
32583       case UROWID:
32584         jj_consume_token(UROWID);
32585         break;
32586       case ARRAY:
32587         jj_consume_token(ARRAY);
32588         break;
32589       case AUTHID:
32590         jj_consume_token(AUTHID);
32591         break;
32592       case ACCESSIBLE:
32593         jj_consume_token(ACCESSIBLE);
32594         jj_consume_token(CHAR_BASE);
32595         break;
32596       case CURRVAL:
32597         jj_consume_token(CURRVAL);
32598         break;
32599       case HOUR:
32600         jj_consume_token(HOUR);
32601         break;
32602       case INTERVAL:
32603         jj_consume_token(INTERVAL);
32604         break;
32605       case MONTH:
32606         jj_consume_token(MONTH);
32607         break;
32608       case OCIROWID:
32609         jj_consume_token(OCIROWID);
32610         break;
32611       case RECORD:
32612         jj_consume_token(RECORD);
32613         break;
32614       case REF:
32615         jj_consume_token(REF);
32616         break;
32617       case ROW:
32618         jj_consume_token(ROW);
32619         break;
32620       case ROWNUM:
32621         jj_consume_token(ROWNUM);
32622         break;
32623       case ROWTYPE:
32624         jj_consume_token(ROWTYPE);
32625         break;
32626       case SECOND:
32627         jj_consume_token(SECOND);
32628         break;
32629       case SET:
32630         jj_consume_token(SET);
32631         break;
32632       case TABLE:
32633         jj_consume_token(TABLE);
32634         break;
32635       case TIMEZONE_REGION:
32636         jj_consume_token(TIMEZONE_REGION);
32637         break;
32638       case TIMEZONE_ABBR:
32639         jj_consume_token(TIMEZONE_ABBR);
32640         break;
32641       case TIMEZONE_MINUTE:
32642         jj_consume_token(TIMEZONE_MINUTE);
32643         break;
32644       case TIMEZONE_HOUR:
32645         jj_consume_token(TIMEZONE_HOUR);
32646         break;
32647       case DOUBLE:
32648         jj_consume_token(DOUBLE);
32649         break;
32650       case PRECISION:
32651         jj_consume_token(PRECISION);
32652         break;
32653       case VARRAY:
32654         jj_consume_token(VARRAY);
32655         break;
32656       case YEAR:
32657         jj_consume_token(YEAR);
32658         break;
32659       case LOCAL:
32660         jj_consume_token(LOCAL);
32661         break;
32662       case WITH:
32663         jj_consume_token(WITH);
32664         break;
32665       case ZONE:
32666         jj_consume_token(ZONE);
32667         break;
32668       case JAVA_INTERFACE_CLASS:
32669         jj_consume_token(JAVA_INTERFACE_CLASS);
32670         break;
32671       case SQLDATA_CLASS:
32672         jj_consume_token(SQLDATA_CLASS);
32673         break;
32674       case CUSTOMDATUM_CLASS:
32675         jj_consume_token(CUSTOMDATUM_CLASS);
32676         break;
32677       case ORADATA_CLASS:
32678         jj_consume_token(ORADATA_CLASS);
32679         break;
32680       default:
32681         jj_la1[458] = jj_gen;
32682         jj_consume_token(-1);
32683         throw new ParseException();
32684       }
32685           jjtree.closeNodeScope(jjtn000, true);
32686           jjtc000 = false;
32687           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32688     } finally {
32689           if (jjtc000) {
32690             jjtree.closeNodeScope(jjtn000, true);
32691           }
32692     }
32693     throw new Error("Missing return statement in function");
32694   }
32695 
32696   final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
32697                                              /*@bgen(jjtree) JavaInterfaceClass */
32698   ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
32699   boolean jjtc000 = true;
32700   jjtree.openNodeScope(jjtn000);
32701     try {
32702       switch (jj_nt.kind) {
32703       case SQLDATA_CLASS:
32704         jj_consume_token(SQLDATA_CLASS);
32705         break;
32706       case CUSTOMDATUM_CLASS:
32707         jj_consume_token(CUSTOMDATUM_CLASS);
32708         break;
32709       case ORADATA_CLASS:
32710         jj_consume_token(ORADATA_CLASS);
32711         break;
32712       default:
32713         jj_la1[459] = jj_gen;
32714         jj_consume_token(-1);
32715         throw new ParseException();
32716       }
32717           jjtree.closeNodeScope(jjtn000, true);
32718           jjtc000 = false;
32719           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32720     } finally {
32721           if (jjtc000) {
32722             jjtree.closeNodeScope(jjtn000, true);
32723           }
32724     }
32725     throw new Error("Missing return statement in function");
32726   }
32727 
32728 /**
32729  * Tests, if the new Token if type ID is identical to the old Token of type ID.
32730  * 
32731  * 2006-05-18 - Matthias Hendler - added: Just for understanding javacc and not used,
32732  *                                        cause to many closing ENDs (IDENTIFIER) were mistyped.
32733  */
32734   final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32735  /*@bgen(jjtree) EqualsOldIDNewID */
32736         ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
32737         boolean jjtc000 = true;
32738         jjtree.openNodeScope(jjtn000);PLSQLNode newID;
32739         Token oldIDToken;
32740         Token newIDToken;
32741     try {
32742       newID = ID();
32743           jjtree.closeNodeScope(jjtn000, true);
32744           jjtc000 = false;
32745                 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
32746                 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
32747                 if (oldIDToken.image.equals(newIDToken.image)) {
32748                         {if (true) return newID;}
32749                 } else {
32750                         {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
32751                                 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
32752                 }
32753     } catch (Throwable jjte000) {
32754           if (jjtc000) {
32755             jjtree.clearNodeScope(jjtn000);
32756             jjtc000 = false;
32757           } else {
32758             jjtree.popNode();
32759           }
32760           if (jjte000 instanceof RuntimeException) {
32761             {if (true) throw (RuntimeException)jjte000;}
32762           }
32763           if (jjte000 instanceof ParseException) {
32764             {if (true) throw (ParseException)jjte000;}
32765           }
32766           {if (true) throw (Error)jjte000;}
32767     } finally {
32768           if (jjtc000) {
32769             jjtree.closeNodeScope(jjtn000, true);
32770           }
32771     }
32772     throw new Error("Missing return statement in function");
32773   }
32774 
32775   private boolean jj_2_1(int xla) {
32776     jj_la = xla; jj_lastpos = jj_scanpos = token;
32777     try { return !jj_3_1(); }
32778     catch(LookaheadSuccess ls) { return true; }
32779     finally { jj_save(0, xla); }
32780   }
32781 
32782   private boolean jj_2_2(int xla) {
32783     jj_la = xla; jj_lastpos = jj_scanpos = token;
32784     try { return !jj_3_2(); }
32785     catch(LookaheadSuccess ls) { return true; }
32786     finally { jj_save(1, xla); }
32787   }
32788 
32789   private boolean jj_2_3(int xla) {
32790     jj_la = xla; jj_lastpos = jj_scanpos = token;
32791     try { return !jj_3_3(); }
32792     catch(LookaheadSuccess ls) { return true; }
32793     finally { jj_save(2, xla); }
32794   }
32795 
32796   private boolean jj_2_4(int xla) {
32797     jj_la = xla; jj_lastpos = jj_scanpos = token;
32798     try { return !jj_3_4(); }
32799     catch(LookaheadSuccess ls) { return true; }
32800     finally { jj_save(3, xla); }
32801   }
32802 
32803   private boolean jj_2_5(int xla) {
32804     jj_la = xla; jj_lastpos = jj_scanpos = token;
32805     try { return !jj_3_5(); }
32806     catch(LookaheadSuccess ls) { return true; }
32807     finally { jj_save(4, xla); }
32808   }
32809 
32810   private boolean jj_2_6(int xla) {
32811     jj_la = xla; jj_lastpos = jj_scanpos = token;
32812     try { return !jj_3_6(); }
32813     catch(LookaheadSuccess ls) { return true; }
32814     finally { jj_save(5, xla); }
32815   }
32816 
32817   private boolean jj_2_7(int xla) {
32818     jj_la = xla; jj_lastpos = jj_scanpos = token;
32819     try { return !jj_3_7(); }
32820     catch(LookaheadSuccess ls) { return true; }
32821     finally { jj_save(6, xla); }
32822   }
32823 
32824   private boolean jj_2_8(int xla) {
32825     jj_la = xla; jj_lastpos = jj_scanpos = token;
32826     try { return !jj_3_8(); }
32827     catch(LookaheadSuccess ls) { return true; }
32828     finally { jj_save(7, xla); }
32829   }
32830 
32831   private boolean jj_2_9(int xla) {
32832     jj_la = xla; jj_lastpos = jj_scanpos = token;
32833     try { return !jj_3_9(); }
32834     catch(LookaheadSuccess ls) { return true; }
32835     finally { jj_save(8, xla); }
32836   }
32837 
32838   private boolean jj_2_10(int xla) {
32839     jj_la = xla; jj_lastpos = jj_scanpos = token;
32840     try { return !jj_3_10(); }
32841     catch(LookaheadSuccess ls) { return true; }
32842     finally { jj_save(9, xla); }
32843   }
32844 
32845   private boolean jj_2_11(int xla) {
32846     jj_la = xla; jj_lastpos = jj_scanpos = token;
32847     try { return !jj_3_11(); }
32848     catch(LookaheadSuccess ls) { return true; }
32849     finally { jj_save(10, xla); }
32850   }
32851 
32852   private boolean jj_2_12(int xla) {
32853     jj_la = xla; jj_lastpos = jj_scanpos = token;
32854     try { return !jj_3_12(); }
32855     catch(LookaheadSuccess ls) { return true; }
32856     finally { jj_save(11, xla); }
32857   }
32858 
32859   private boolean jj_2_13(int xla) {
32860     jj_la = xla; jj_lastpos = jj_scanpos = token;
32861     try { return !jj_3_13(); }
32862     catch(LookaheadSuccess ls) { return true; }
32863     finally { jj_save(12, xla); }
32864   }
32865 
32866   private boolean jj_2_14(int xla) {
32867     jj_la = xla; jj_lastpos = jj_scanpos = token;
32868     try { return !jj_3_14(); }
32869     catch(LookaheadSuccess ls) { return true; }
32870     finally { jj_save(13, xla); }
32871   }
32872 
32873   private boolean jj_2_15(int xla) {
32874     jj_la = xla; jj_lastpos = jj_scanpos = token;
32875     try { return !jj_3_15(); }
32876     catch(LookaheadSuccess ls) { return true; }
32877     finally { jj_save(14, xla); }
32878   }
32879 
32880   private boolean jj_2_16(int xla) {
32881     jj_la = xla; jj_lastpos = jj_scanpos = token;
32882     try { return !jj_3_16(); }
32883     catch(LookaheadSuccess ls) { return true; }
32884     finally { jj_save(15, xla); }
32885   }
32886 
32887   private boolean jj_2_17(int xla) {
32888     jj_la = xla; jj_lastpos = jj_scanpos = token;
32889     try { return !jj_3_17(); }
32890     catch(LookaheadSuccess ls) { return true; }
32891     finally { jj_save(16, xla); }
32892   }
32893 
32894   private boolean jj_2_18(int xla) {
32895     jj_la = xla; jj_lastpos = jj_scanpos = token;
32896     try { return !jj_3_18(); }
32897     catch(LookaheadSuccess ls) { return true; }
32898     finally { jj_save(17, xla); }
32899   }
32900 
32901   private boolean jj_2_19(int xla) {
32902     jj_la = xla; jj_lastpos = jj_scanpos = token;
32903     try { return !jj_3_19(); }
32904     catch(LookaheadSuccess ls) { return true; }
32905     finally { jj_save(18, xla); }
32906   }
32907 
32908   private boolean jj_2_20(int xla) {
32909     jj_la = xla; jj_lastpos = jj_scanpos = token;
32910     try { return !jj_3_20(); }
32911     catch(LookaheadSuccess ls) { return true; }
32912     finally { jj_save(19, xla); }
32913   }
32914 
32915   private boolean jj_2_21(int xla) {
32916     jj_la = xla; jj_lastpos = jj_scanpos = token;
32917     try { return !jj_3_21(); }
32918     catch(LookaheadSuccess ls) { return true; }
32919     finally { jj_save(20, xla); }
32920   }
32921 
32922   private boolean jj_2_22(int xla) {
32923     jj_la = xla; jj_lastpos = jj_scanpos = token;
32924     try { return !jj_3_22(); }
32925     catch(LookaheadSuccess ls) { return true; }
32926     finally { jj_save(21, xla); }
32927   }
32928 
32929   private boolean jj_2_23(int xla) {
32930     jj_la = xla; jj_lastpos = jj_scanpos = token;
32931     try { return !jj_3_23(); }
32932     catch(LookaheadSuccess ls) { return true; }
32933     finally { jj_save(22, xla); }
32934   }
32935 
32936   private boolean jj_2_24(int xla) {
32937     jj_la = xla; jj_lastpos = jj_scanpos = token;
32938     try { return !jj_3_24(); }
32939     catch(LookaheadSuccess ls) { return true; }
32940     finally { jj_save(23, xla); }
32941   }
32942 
32943   private boolean jj_2_25(int xla) {
32944     jj_la = xla; jj_lastpos = jj_scanpos = token;
32945     try { return !jj_3_25(); }
32946     catch(LookaheadSuccess ls) { return true; }
32947     finally { jj_save(24, xla); }
32948   }
32949 
32950   private boolean jj_2_26(int xla) {
32951     jj_la = xla; jj_lastpos = jj_scanpos = token;
32952     try { return !jj_3_26(); }
32953     catch(LookaheadSuccess ls) { return true; }
32954     finally { jj_save(25, xla); }
32955   }
32956 
32957   private boolean jj_2_27(int xla) {
32958     jj_la = xla; jj_lastpos = jj_scanpos = token;
32959     try { return !jj_3_27(); }
32960     catch(LookaheadSuccess ls) { return true; }
32961     finally { jj_save(26, xla); }
32962   }
32963 
32964   private boolean jj_2_28(int xla) {
32965     jj_la = xla; jj_lastpos = jj_scanpos = token;
32966     try { return !jj_3_28(); }
32967     catch(LookaheadSuccess ls) { return true; }
32968     finally { jj_save(27, xla); }
32969   }
32970 
32971   private boolean jj_2_29(int xla) {
32972     jj_la = xla; jj_lastpos = jj_scanpos = token;
32973     try { return !jj_3_29(); }
32974     catch(LookaheadSuccess ls) { return true; }
32975     finally { jj_save(28, xla); }
32976   }
32977 
32978   private boolean jj_2_30(int xla) {
32979     jj_la = xla; jj_lastpos = jj_scanpos = token;
32980     try { return !jj_3_30(); }
32981     catch(LookaheadSuccess ls) { return true; }
32982     finally { jj_save(29, xla); }
32983   }
32984 
32985   private boolean jj_2_31(int xla) {
32986     jj_la = xla; jj_lastpos = jj_scanpos = token;
32987     try { return !jj_3_31(); }
32988     catch(LookaheadSuccess ls) { return true; }
32989     finally { jj_save(30, xla); }
32990   }
32991 
32992   private boolean jj_2_32(int xla) {
32993     jj_la = xla; jj_lastpos = jj_scanpos = token;
32994     try { return !jj_3_32(); }
32995     catch(LookaheadSuccess ls) { return true; }
32996     finally { jj_save(31, xla); }
32997   }
32998 
32999   private boolean jj_2_33(int xla) {
33000     jj_la = xla; jj_lastpos = jj_scanpos = token;
33001     try { return !jj_3_33(); }
33002     catch(LookaheadSuccess ls) { return true; }
33003     finally { jj_save(32, xla); }
33004   }
33005 
33006   private boolean jj_2_34(int xla) {
33007     jj_la = xla; jj_lastpos = jj_scanpos = token;
33008     try { return !jj_3_34(); }
33009     catch(LookaheadSuccess ls) { return true; }
33010     finally { jj_save(33, xla); }
33011   }
33012 
33013   private boolean jj_2_35(int xla) {
33014     jj_la = xla; jj_lastpos = jj_scanpos = token;
33015     try { return !jj_3_35(); }
33016     catch(LookaheadSuccess ls) { return true; }
33017     finally { jj_save(34, xla); }
33018   }
33019 
33020   private boolean jj_2_36(int xla) {
33021     jj_la = xla; jj_lastpos = jj_scanpos = token;
33022     try { return !jj_3_36(); }
33023     catch(LookaheadSuccess ls) { return true; }
33024     finally { jj_save(35, xla); }
33025   }
33026 
33027   private boolean jj_2_37(int xla) {
33028     jj_la = xla; jj_lastpos = jj_scanpos = token;
33029     try { return !jj_3_37(); }
33030     catch(LookaheadSuccess ls) { return true; }
33031     finally { jj_save(36, xla); }
33032   }
33033 
33034   private boolean jj_2_38(int xla) {
33035     jj_la = xla; jj_lastpos = jj_scanpos = token;
33036     try { return !jj_3_38(); }
33037     catch(LookaheadSuccess ls) { return true; }
33038     finally { jj_save(37, xla); }
33039   }
33040 
33041   private boolean jj_2_39(int xla) {
33042     jj_la = xla; jj_lastpos = jj_scanpos = token;
33043     try { return !jj_3_39(); }
33044     catch(LookaheadSuccess ls) { return true; }
33045     finally { jj_save(38, xla); }
33046   }
33047 
33048   private boolean jj_2_40(int xla) {
33049     jj_la = xla; jj_lastpos = jj_scanpos = token;
33050     try { return !jj_3_40(); }
33051     catch(LookaheadSuccess ls) { return true; }
33052     finally { jj_save(39, xla); }
33053   }
33054 
33055   private boolean jj_2_41(int xla) {
33056     jj_la = xla; jj_lastpos = jj_scanpos = token;
33057     try { return !jj_3_41(); }
33058     catch(LookaheadSuccess ls) { return true; }
33059     finally { jj_save(40, xla); }
33060   }
33061 
33062   private boolean jj_2_42(int xla) {
33063     jj_la = xla; jj_lastpos = jj_scanpos = token;
33064     try { return !jj_3_42(); }
33065     catch(LookaheadSuccess ls) { return true; }
33066     finally { jj_save(41, xla); }
33067   }
33068 
33069   private boolean jj_2_43(int xla) {
33070     jj_la = xla; jj_lastpos = jj_scanpos = token;
33071     try { return !jj_3_43(); }
33072     catch(LookaheadSuccess ls) { return true; }
33073     finally { jj_save(42, xla); }
33074   }
33075 
33076   private boolean jj_2_44(int xla) {
33077     jj_la = xla; jj_lastpos = jj_scanpos = token;
33078     try { return !jj_3_44(); }
33079     catch(LookaheadSuccess ls) { return true; }
33080     finally { jj_save(43, xla); }
33081   }
33082 
33083   private boolean jj_2_45(int xla) {
33084     jj_la = xla; jj_lastpos = jj_scanpos = token;
33085     try { return !jj_3_45(); }
33086     catch(LookaheadSuccess ls) { return true; }
33087     finally { jj_save(44, xla); }
33088   }
33089 
33090   private boolean jj_2_46(int xla) {
33091     jj_la = xla; jj_lastpos = jj_scanpos = token;
33092     try { return !jj_3_46(); }
33093     catch(LookaheadSuccess ls) { return true; }
33094     finally { jj_save(45, xla); }
33095   }
33096 
33097   private boolean jj_2_47(int xla) {
33098     jj_la = xla; jj_lastpos = jj_scanpos = token;
33099     try { return !jj_3_47(); }
33100     catch(LookaheadSuccess ls) { return true; }
33101     finally { jj_save(46, xla); }
33102   }
33103 
33104   private boolean jj_2_48(int xla) {
33105     jj_la = xla; jj_lastpos = jj_scanpos = token;
33106     try { return !jj_3_48(); }
33107     catch(LookaheadSuccess ls) { return true; }
33108     finally { jj_save(47, xla); }
33109   }
33110 
33111   private boolean jj_2_49(int xla) {
33112     jj_la = xla; jj_lastpos = jj_scanpos = token;
33113     try { return !jj_3_49(); }
33114     catch(LookaheadSuccess ls) { return true; }
33115     finally { jj_save(48, xla); }
33116   }
33117 
33118   private boolean jj_2_50(int xla) {
33119     jj_la = xla; jj_lastpos = jj_scanpos = token;
33120     try { return !jj_3_50(); }
33121     catch(LookaheadSuccess ls) { return true; }
33122     finally { jj_save(49, xla); }
33123   }
33124 
33125   private boolean jj_2_51(int xla) {
33126     jj_la = xla; jj_lastpos = jj_scanpos = token;
33127     try { return !jj_3_51(); }
33128     catch(LookaheadSuccess ls) { return true; }
33129     finally { jj_save(50, xla); }
33130   }
33131 
33132   private boolean jj_2_52(int xla) {
33133     jj_la = xla; jj_lastpos = jj_scanpos = token;
33134     try { return !jj_3_52(); }
33135     catch(LookaheadSuccess ls) { return true; }
33136     finally { jj_save(51, xla); }
33137   }
33138 
33139   private boolean jj_2_53(int xla) {
33140     jj_la = xla; jj_lastpos = jj_scanpos = token;
33141     try { return !jj_3_53(); }
33142     catch(LookaheadSuccess ls) { return true; }
33143     finally { jj_save(52, xla); }
33144   }
33145 
33146   private boolean jj_2_54(int xla) {
33147     jj_la = xla; jj_lastpos = jj_scanpos = token;
33148     try { return !jj_3_54(); }
33149     catch(LookaheadSuccess ls) { return true; }
33150     finally { jj_save(53, xla); }
33151   }
33152 
33153   private boolean jj_2_55(int xla) {
33154     jj_la = xla; jj_lastpos = jj_scanpos = token;
33155     try { return !jj_3_55(); }
33156     catch(LookaheadSuccess ls) { return true; }
33157     finally { jj_save(54, xla); }
33158   }
33159 
33160   private boolean jj_2_56(int xla) {
33161     jj_la = xla; jj_lastpos = jj_scanpos = token;
33162     try { return !jj_3_56(); }
33163     catch(LookaheadSuccess ls) { return true; }
33164     finally { jj_save(55, xla); }
33165   }
33166 
33167   private boolean jj_2_57(int xla) {
33168     jj_la = xla; jj_lastpos = jj_scanpos = token;
33169     try { return !jj_3_57(); }
33170     catch(LookaheadSuccess ls) { return true; }
33171     finally { jj_save(56, xla); }
33172   }
33173 
33174   private boolean jj_2_58(int xla) {
33175     jj_la = xla; jj_lastpos = jj_scanpos = token;
33176     try { return !jj_3_58(); }
33177     catch(LookaheadSuccess ls) { return true; }
33178     finally { jj_save(57, xla); }
33179   }
33180 
33181   private boolean jj_2_59(int xla) {
33182     jj_la = xla; jj_lastpos = jj_scanpos = token;
33183     try { return !jj_3_59(); }
33184     catch(LookaheadSuccess ls) { return true; }
33185     finally { jj_save(58, xla); }
33186   }
33187 
33188   private boolean jj_2_60(int xla) {
33189     jj_la = xla; jj_lastpos = jj_scanpos = token;
33190     try { return !jj_3_60(); }
33191     catch(LookaheadSuccess ls) { return true; }
33192     finally { jj_save(59, xla); }
33193   }
33194 
33195   private boolean jj_2_61(int xla) {
33196     jj_la = xla; jj_lastpos = jj_scanpos = token;
33197     try { return !jj_3_61(); }
33198     catch(LookaheadSuccess ls) { return true; }
33199     finally { jj_save(60, xla); }
33200   }
33201 
33202   private boolean jj_2_62(int xla) {
33203     jj_la = xla; jj_lastpos = jj_scanpos = token;
33204     try { return !jj_3_62(); }
33205     catch(LookaheadSuccess ls) { return true; }
33206     finally { jj_save(61, xla); }
33207   }
33208 
33209   private boolean jj_2_63(int xla) {
33210     jj_la = xla; jj_lastpos = jj_scanpos = token;
33211     try { return !jj_3_63(); }
33212     catch(LookaheadSuccess ls) { return true; }
33213     finally { jj_save(62, xla); }
33214   }
33215 
33216   private boolean jj_2_64(int xla) {
33217     jj_la = xla; jj_lastpos = jj_scanpos = token;
33218     try { return !jj_3_64(); }
33219     catch(LookaheadSuccess ls) { return true; }
33220     finally { jj_save(63, xla); }
33221   }
33222 
33223   private boolean jj_2_65(int xla) {
33224     jj_la = xla; jj_lastpos = jj_scanpos = token;
33225     try { return !jj_3_65(); }
33226     catch(LookaheadSuccess ls) { return true; }
33227     finally { jj_save(64, xla); }
33228   }
33229 
33230   private boolean jj_2_66(int xla) {
33231     jj_la = xla; jj_lastpos = jj_scanpos = token;
33232     try { return !jj_3_66(); }
33233     catch(LookaheadSuccess ls) { return true; }
33234     finally { jj_save(65, xla); }
33235   }
33236 
33237   private boolean jj_2_67(int xla) {
33238     jj_la = xla; jj_lastpos = jj_scanpos = token;
33239     try { return !jj_3_67(); }
33240     catch(LookaheadSuccess ls) { return true; }
33241     finally { jj_save(66, xla); }
33242   }
33243 
33244   private boolean jj_2_68(int xla) {
33245     jj_la = xla; jj_lastpos = jj_scanpos = token;
33246     try { return !jj_3_68(); }
33247     catch(LookaheadSuccess ls) { return true; }
33248     finally { jj_save(67, xla); }
33249   }
33250 
33251   private boolean jj_2_69(int xla) {
33252     jj_la = xla; jj_lastpos = jj_scanpos = token;
33253     try { return !jj_3_69(); }
33254     catch(LookaheadSuccess ls) { return true; }
33255     finally { jj_save(68, xla); }
33256   }
33257 
33258   private boolean jj_2_70(int xla) {
33259     jj_la = xla; jj_lastpos = jj_scanpos = token;
33260     try { return !jj_3_70(); }
33261     catch(LookaheadSuccess ls) { return true; }
33262     finally { jj_save(69, xla); }
33263   }
33264 
33265   private boolean jj_2_71(int xla) {
33266     jj_la = xla; jj_lastpos = jj_scanpos = token;
33267     try { return !jj_3_71(); }
33268     catch(LookaheadSuccess ls) { return true; }
33269     finally { jj_save(70, xla); }
33270   }
33271 
33272   private boolean jj_2_72(int xla) {
33273     jj_la = xla; jj_lastpos = jj_scanpos = token;
33274     try { return !jj_3_72(); }
33275     catch(LookaheadSuccess ls) { return true; }
33276     finally { jj_save(71, xla); }
33277   }
33278 
33279   private boolean jj_2_73(int xla) {
33280     jj_la = xla; jj_lastpos = jj_scanpos = token;
33281     try { return !jj_3_73(); }
33282     catch(LookaheadSuccess ls) { return true; }
33283     finally { jj_save(72, xla); }
33284   }
33285 
33286   private boolean jj_2_74(int xla) {
33287     jj_la = xla; jj_lastpos = jj_scanpos = token;
33288     try { return !jj_3_74(); }
33289     catch(LookaheadSuccess ls) { return true; }
33290     finally { jj_save(73, xla); }
33291   }
33292 
33293   private boolean jj_2_75(int xla) {
33294     jj_la = xla; jj_lastpos = jj_scanpos = token;
33295     try { return !jj_3_75(); }
33296     catch(LookaheadSuccess ls) { return true; }
33297     finally { jj_save(74, xla); }
33298   }
33299 
33300   private boolean jj_2_76(int xla) {
33301     jj_la = xla; jj_lastpos = jj_scanpos = token;
33302     try { return !jj_3_76(); }
33303     catch(LookaheadSuccess ls) { return true; }
33304     finally { jj_save(75, xla); }
33305   }
33306 
33307   private boolean jj_2_77(int xla) {
33308     jj_la = xla; jj_lastpos = jj_scanpos = token;
33309     try { return !jj_3_77(); }
33310     catch(LookaheadSuccess ls) { return true; }
33311     finally { jj_save(76, xla); }
33312   }
33313 
33314   private boolean jj_2_78(int xla) {
33315     jj_la = xla; jj_lastpos = jj_scanpos = token;
33316     try { return !jj_3_78(); }
33317     catch(LookaheadSuccess ls) { return true; }
33318     finally { jj_save(77, xla); }
33319   }
33320 
33321   private boolean jj_2_79(int xla) {
33322     jj_la = xla; jj_lastpos = jj_scanpos = token;
33323     try { return !jj_3_79(); }
33324     catch(LookaheadSuccess ls) { return true; }
33325     finally { jj_save(78, xla); }
33326   }
33327 
33328   private boolean jj_2_80(int xla) {
33329     jj_la = xla; jj_lastpos = jj_scanpos = token;
33330     try { return !jj_3_80(); }
33331     catch(LookaheadSuccess ls) { return true; }
33332     finally { jj_save(79, xla); }
33333   }
33334 
33335   private boolean jj_2_81(int xla) {
33336     jj_la = xla; jj_lastpos = jj_scanpos = token;
33337     try { return !jj_3_81(); }
33338     catch(LookaheadSuccess ls) { return true; }
33339     finally { jj_save(80, xla); }
33340   }
33341 
33342   private boolean jj_2_82(int xla) {
33343     jj_la = xla; jj_lastpos = jj_scanpos = token;
33344     try { return !jj_3_82(); }
33345     catch(LookaheadSuccess ls) { return true; }
33346     finally { jj_save(81, xla); }
33347   }
33348 
33349   private boolean jj_2_83(int xla) {
33350     jj_la = xla; jj_lastpos = jj_scanpos = token;
33351     try { return !jj_3_83(); }
33352     catch(LookaheadSuccess ls) { return true; }
33353     finally { jj_save(82, xla); }
33354   }
33355 
33356   private boolean jj_2_84(int xla) {
33357     jj_la = xla; jj_lastpos = jj_scanpos = token;
33358     try { return !jj_3_84(); }
33359     catch(LookaheadSuccess ls) { return true; }
33360     finally { jj_save(83, xla); }
33361   }
33362 
33363   private boolean jj_2_85(int xla) {
33364     jj_la = xla; jj_lastpos = jj_scanpos = token;
33365     try { return !jj_3_85(); }
33366     catch(LookaheadSuccess ls) { return true; }
33367     finally { jj_save(84, xla); }
33368   }
33369 
33370   private boolean jj_3R_565() {
33371     Token xsp;
33372     xsp = jj_scanpos;
33373     if (jj_scan_token(183)) jj_scanpos = xsp;
33374     if (jj_scan_token(NULL)) return true;
33375     return false;
33376   }
33377 
33378   private boolean jj_3R_179() {
33379     Token xsp;
33380     xsp = jj_scanpos;
33381     if (jj_3_77()) jj_scanpos = xsp;
33382     if (jj_3R_124()) return true;
33383     return false;
33384   }
33385 
33386   private boolean jj_3_78() {
33387     if (jj_scan_token(NESTED)) return true;
33388     if (jj_scan_token(TABLE)) return true;
33389     return false;
33390   }
33391 
33392   private boolean jj_3R_530() {
33393     if (jj_scan_token(6)) return true;
33394     if (jj_3R_234()) return true;
33395     return false;
33396   }
33397 
33398   private boolean jj_3R_525() {
33399     if (jj_scan_token(VARYING)) return true;
33400     if (jj_scan_token(ARRAY)) return true;
33401     return false;
33402   }
33403 
33404   private boolean jj_3R_178() {
33405     if (jj_scan_token(OR)) return true;
33406     Token xsp;
33407     xsp = jj_scanpos;
33408     if (jj_3R_269()) {
33409     jj_scanpos = xsp;
33410     if (jj_3R_270()) return true;
33411     }
33412     return false;
33413   }
33414 
33415   private boolean jj_3R_529() {
33416     if (jj_scan_token(RETURN)) return true;
33417     if (jj_3R_236()) return true;
33418     return false;
33419   }
33420 
33421   private boolean jj_3R_176() {
33422     Token xsp;
33423     xsp = jj_scanpos;
33424     if (jj_scan_token(93)) {
33425     jj_scanpos = xsp;
33426     if (jj_scan_token(144)) {
33427     jj_scanpos = xsp;
33428     if (jj_scan_token(297)) return true;
33429     }
33430     }
33431     xsp = jj_scanpos;
33432     if (jj_3_74()) jj_scanpos = xsp;
33433     return false;
33434   }
33435 
33436   private boolean jj_3R_527() {
33437     if (jj_scan_token(NOT)) return true;
33438     if (jj_scan_token(NULL)) return true;
33439     return false;
33440   }
33441 
33442   private boolean jj_3R_266() {
33443     if (jj_scan_token(OR)) return true;
33444     if (jj_scan_token(REPLACE)) return true;
33445     return false;
33446   }
33447 
33448   private boolean jj_3R_123() {
33449     Token xsp;
33450     xsp = jj_scanpos;
33451     if (jj_scan_token(114)) {
33452     jj_scanpos = xsp;
33453     if (jj_3R_200()) return true;
33454     }
33455     while (true) {
33456       xsp = jj_scanpos;
33457       if (jj_3R_201()) { jj_scanpos = xsp; break; }
33458     }
33459     return false;
33460   }
33461 
33462   private boolean jj_3R_499() {
33463     if (jj_3R_236()) return true;
33464     return false;
33465   }
33466 
33467   private boolean jj_3R_175() {
33468     if (jj_scan_token(CREATE)) return true;
33469     Token xsp;
33470     xsp = jj_scanpos;
33471     if (jj_3R_266()) jj_scanpos = xsp;
33472     xsp = jj_scanpos;
33473     if (jj_3R_267()) jj_scanpos = xsp;
33474     return false;
33475   }
33476 
33477   private boolean jj_3R_498() {
33478     if (jj_scan_token(5)) return true;
33479     if (jj_3R_234()) return true;
33480     Token xsp;
33481     while (true) {
33482       xsp = jj_scanpos;
33483       if (jj_3R_530()) { jj_scanpos = xsp; break; }
33484     }
33485     if (jj_scan_token(7)) return true;
33486     return false;
33487   }
33488 
33489   private boolean jj_3R_108() {
33490     Token xsp;
33491     xsp = jj_scanpos;
33492     if (jj_3R_175()) jj_scanpos = xsp;
33493     if (jj_scan_token(TRIGGER)) return true;
33494     if (jj_3R_155()) return true;
33495     xsp = jj_scanpos;
33496     if (jj_scan_token(322)) {
33497     jj_scanpos = xsp;
33498     if (jj_scan_token(321)) {
33499     jj_scanpos = xsp;
33500     if (jj_scan_token(323)) {
33501     jj_scanpos = xsp;
33502     if (jj_scan_token(121)) return true;
33503     }
33504     }
33505     }
33506     xsp = jj_scanpos;
33507     if (jj_3R_176()) {
33508     jj_scanpos = xsp;
33509     if (jj_3R_177()) return true;
33510     }
33511     while (true) {
33512       xsp = jj_scanpos;
33513       if (jj_3R_178()) { jj_scanpos = xsp; break; }
33514     }
33515     if (jj_scan_token(ON)) return true;
33516     xsp = jj_scanpos;
33517     if (jj_scan_token(348)) {
33518     jj_scanpos = xsp;
33519     if (jj_3_78()) {
33520     jj_scanpos = xsp;
33521     if (jj_3R_179()) return true;
33522     }
33523     }
33524     return false;
33525   }
33526 
33527   private boolean jj_3R_497() {
33528     if (jj_scan_token(REF)) return true;
33529     if (jj_scan_token(CURSOR)) return true;
33530     Token xsp;
33531     xsp = jj_scanpos;
33532     if (jj_3R_529()) jj_scanpos = xsp;
33533     return false;
33534   }
33535 
33536   private boolean jj_3R_522() {
33537     if (jj_3R_124()) return true;
33538     if (jj_3R_236()) return true;
33539     Token xsp;
33540     xsp = jj_scanpos;
33541     if (jj_3R_565()) jj_scanpos = xsp;
33542     xsp = jj_scanpos;
33543     if (jj_3R_566()) jj_scanpos = xsp;
33544     return false;
33545   }
33546 
33547   private boolean jj_3R_496() {
33548     Token xsp;
33549     xsp = jj_scanpos;
33550     if (jj_scan_token(271)) {
33551     jj_scanpos = xsp;
33552     if (jj_scan_token(310)) {
33553     jj_scanpos = xsp;
33554     if (jj_3R_525()) return true;
33555     }
33556     }
33557     xsp = jj_scanpos;
33558     if (jj_3R_526()) jj_scanpos = xsp;
33559     if (jj_scan_token(OF)) return true;
33560     if (jj_3R_236()) return true;
33561     xsp = jj_scanpos;
33562     if (jj_3R_527()) jj_scanpos = xsp;
33563     xsp = jj_scanpos;
33564     if (jj_3R_528()) jj_scanpos = xsp;
33565     return false;
33566   }
33567 
33568   private boolean jj_3R_495() {
33569     if (jj_scan_token(RECORD)) return true;
33570     if (jj_scan_token(5)) return true;
33571     if (jj_3R_522()) return true;
33572     Token xsp;
33573     while (true) {
33574       xsp = jj_scanpos;
33575       if (jj_3R_524()) { jj_scanpos = xsp; break; }
33576     }
33577     if (jj_scan_token(7)) return true;
33578     return false;
33579   }
33580 
33581   private boolean jj_3R_494() {
33582     if (jj_scan_token(OBJECT)) return true;
33583     if (jj_scan_token(5)) return true;
33584     if (jj_3R_522()) return true;
33585     Token xsp;
33586     while (true) {
33587       xsp = jj_scanpos;
33588       if (jj_3R_523()) { jj_scanpos = xsp; break; }
33589     }
33590     if (jj_scan_token(7)) return true;
33591     return false;
33592   }
33593 
33594   private boolean jj_3R_645() {
33595     if (jj_3R_174()) return true;
33596     return false;
33597   }
33598 
33599   private boolean jj_3_44() {
33600     if (jj_scan_token(NEW)) return true;
33601     Token xsp;
33602     xsp = jj_scanpos;
33603     if (jj_scan_token(68)) {
33604     jj_scanpos = xsp;
33605     if (jj_scan_token(191)) {
33606     jj_scanpos = xsp;
33607     if (jj_scan_token(190)) {
33608     jj_scanpos = xsp;
33609     if (jj_scan_token(189)) {
33610     jj_scanpos = xsp;
33611     if (jj_scan_token(188)) {
33612     jj_scanpos = xsp;
33613     if (jj_scan_token(192)) return true;
33614     }
33615     }
33616     }
33617     }
33618     }
33619     return false;
33620   }
33621 
33622   private boolean jj_3R_595() {
33623     if (jj_3R_174()) return true;
33624     return false;
33625   }
33626 
33627   private boolean jj_3R_646() {
33628     Token xsp;
33629     xsp = jj_scanpos;
33630     if (jj_scan_token(137)) {
33631     jj_scanpos = xsp;
33632     if (jj_scan_token(207)) {
33633     jj_scanpos = xsp;
33634     if (jj_scan_token(138)) return true;
33635     }
33636     }
33637     return false;
33638   }
33639 
33640   private boolean jj_3R_493() {
33641     if (jj_scan_token(NOT)) return true;
33642     if (jj_scan_token(NULL)) return true;
33643     return false;
33644   }
33645 
33646   private boolean jj_3R_521() {
33647     if (jj_scan_token(RANGE)) return true;
33648     if (jj_3R_484()) return true;
33649     if (jj_scan_token(12)) return true;
33650     if (jj_3R_484()) return true;
33651     return false;
33652   }
33653 
33654   private boolean jj_3R_520() {
33655     if (jj_scan_token(5)) return true;
33656     if (jj_scan_token(IDENTIFIER)) return true;
33657     if (jj_scan_token(7)) return true;
33658     return false;
33659   }
33660 
33661   private boolean jj_3R_492() {
33662     Token xsp;
33663     xsp = jj_scanpos;
33664     if (jj_3R_520()) {
33665     jj_scanpos = xsp;
33666     if (jj_3R_521()) return true;
33667     }
33668     return false;
33669   }
33670 
33671   private boolean jj_3R_647() {
33672     if (jj_scan_token(IN)) return true;
33673     Token xsp;
33674     xsp = jj_scanpos;
33675     if (jj_scan_token(207)) jj_scanpos = xsp;
33676     return false;
33677   }
33678 
33679   private boolean jj_3R_644() {
33680     Token xsp;
33681     xsp = jj_scanpos;
33682     if (jj_3R_647()) {
33683     jj_scanpos = xsp;
33684     if (jj_scan_token(207)) return true;
33685     }
33686     return false;
33687   }
33688 
33689   private boolean jj_3R_643() {
33690     if (jj_scan_token(6)) return true;
33691     Token xsp;
33692     xsp = jj_scanpos;
33693     if (jj_3R_646()) jj_scanpos = xsp;
33694     if (jj_3R_234()) return true;
33695     return false;
33696   }
33697 
33698   private boolean jj_3R_244() {
33699     if (jj_scan_token(TYPE)) return true;
33700     if (jj_3R_120()) return true;
33701     Token xsp;
33702     xsp = jj_scanpos;
33703     if (jj_scan_token(152)) {
33704     jj_scanpos = xsp;
33705     if (jj_scan_token(51)) return true;
33706     }
33707     xsp = jj_scanpos;
33708     if (jj_3_44()) {
33709     jj_scanpos = xsp;
33710     if (jj_3R_494()) {
33711     jj_scanpos = xsp;
33712     if (jj_3R_495()) {
33713     jj_scanpos = xsp;
33714     if (jj_3R_496()) {
33715     jj_scanpos = xsp;
33716     if (jj_3R_497()) {
33717     jj_scanpos = xsp;
33718     if (jj_3R_498()) {
33719     jj_scanpos = xsp;
33720     if (jj_3R_499()) return true;
33721     }
33722     }
33723     }
33724     }
33725     }
33726     }
33727     return false;
33728   }
33729 
33730   private boolean jj_3R_641() {
33731     if (jj_scan_token(6)) return true;
33732     if (jj_3R_234()) return true;
33733     return false;
33734   }
33735 
33736   private boolean jj_3R_640() {
33737     if (jj_scan_token(6)) return true;
33738     Token xsp;
33739     xsp = jj_scanpos;
33740     if (jj_3R_644()) jj_scanpos = xsp;
33741     if (jj_3R_234()) return true;
33742     return false;
33743   }
33744 
33745   private boolean jj_3R_243() {
33746     if (jj_scan_token(SUBTYPE)) return true;
33747     if (jj_3R_120()) return true;
33748     if (jj_scan_token(IS)) return true;
33749     if (jj_3R_236()) return true;
33750     Token xsp;
33751     xsp = jj_scanpos;
33752     if (jj_3R_492()) jj_scanpos = xsp;
33753     xsp = jj_scanpos;
33754     if (jj_3R_493()) jj_scanpos = xsp;
33755     return false;
33756   }
33757 
33758   private boolean jj_3R_620() {
33759     if (jj_3R_174()) return true;
33760     return false;
33761   }
33762 
33763   private boolean jj_3R_153() {
33764     Token xsp;
33765     xsp = jj_scanpos;
33766     if (jj_3R_243()) {
33767     jj_scanpos = xsp;
33768     if (jj_3R_244()) return true;
33769     }
33770     if (jj_scan_token(4)) return true;
33771     return false;
33772   }
33773 
33774   private boolean jj_3R_556() {
33775     if (jj_scan_token(LIMIT)) return true;
33776     if (jj_3R_234()) return true;
33777     return false;
33778   }
33779 
33780   private boolean jj_3R_597() {
33781     if (jj_scan_token(CC_ELSE)) return true;
33782     Token xsp;
33783     if (jj_3R_620()) return true;
33784     while (true) {
33785       xsp = jj_scanpos;
33786       if (jj_3R_620()) { jj_scanpos = xsp; break; }
33787     }
33788     return false;
33789   }
33790 
33791   private boolean jj_3R_596() {
33792     if (jj_scan_token(CC_ELSIF)) return true;
33793     if (jj_3R_344()) return true;
33794     if (jj_scan_token(CC_THEN)) return true;
33795     Token xsp;
33796     if (jj_3R_645()) return true;
33797     while (true) {
33798       xsp = jj_scanpos;
33799       if (jj_3R_645()) { jj_scanpos = xsp; break; }
33800     }
33801     return false;
33802   }
33803 
33804   private boolean jj_3R_457() {
33805     if (jj_scan_token(CC_ERROR)) return true;
33806     if (jj_3R_234()) return true;
33807     if (jj_scan_token(CC_END)) return true;
33808     return false;
33809   }
33810 
33811   private boolean jj_3R_404() {
33812     if (jj_scan_token(INTERFACE)) return true;
33813     if (jj_scan_token(5)) return true;
33814     return false;
33815   }
33816 
33817   private boolean jj_3R_403() {
33818     if (jj_scan_token(EXCEPTION_INIT)) return true;
33819     if (jj_scan_token(5)) return true;
33820     return false;
33821   }
33822 
33823   private boolean jj_3R_456() {
33824     if (jj_scan_token(CC_IF)) return true;
33825     if (jj_3R_344()) return true;
33826     if (jj_scan_token(CC_THEN)) return true;
33827     Token xsp;
33828     while (true) {
33829       xsp = jj_scanpos;
33830       if (jj_3R_595()) { jj_scanpos = xsp; break; }
33831     }
33832     while (true) {
33833       xsp = jj_scanpos;
33834       if (jj_3R_596()) { jj_scanpos = xsp; break; }
33835     }
33836     while (true) {
33837       xsp = jj_scanpos;
33838       if (jj_3R_597()) { jj_scanpos = xsp; break; }
33839     }
33840     if (jj_scan_token(CC_END)) return true;
33841     return false;
33842   }
33843 
33844   private boolean jj_3R_618() {
33845     Token xsp;
33846     xsp = jj_scanpos;
33847     if (jj_scan_token(137)) {
33848     jj_scanpos = xsp;
33849     if (jj_scan_token(207)) {
33850     jj_scanpos = xsp;
33851     if (jj_scan_token(138)) return true;
33852     }
33853     }
33854     return false;
33855   }
33856 
33857   private boolean jj_3R_639() {
33858     if (jj_scan_token(6)) return true;
33859     if (jj_3R_295()) return true;
33860     return false;
33861   }
33862 
33863   private boolean jj_3R_421() {
33864     Token xsp;
33865     xsp = jj_scanpos;
33866     if (jj_3R_456()) {
33867     jj_scanpos = xsp;
33868     if (jj_3R_457()) return true;
33869     }
33870     return false;
33871   }
33872 
33873   private boolean jj_3R_402() {
33874     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33875     if (jj_scan_token(5)) return true;
33876     return false;
33877   }
33878 
33879   private boolean jj_3R_619() {
33880     if (jj_scan_token(IN)) return true;
33881     Token xsp;
33882     xsp = jj_scanpos;
33883     if (jj_scan_token(207)) jj_scanpos = xsp;
33884     return false;
33885   }
33886 
33887   private boolean jj_3R_594() {
33888     Token xsp;
33889     xsp = jj_scanpos;
33890     if (jj_3R_619()) {
33891     jj_scanpos = xsp;
33892     if (jj_scan_token(207)) return true;
33893     }
33894     return false;
33895   }
33896 
33897   private boolean jj_3R_554() {
33898     if (jj_scan_token(BULK)) return true;
33899     if (jj_scan_token(COLLECT)) return true;
33900     return false;
33901   }
33902 
33903   private boolean jj_3R_555() {
33904     if (jj_scan_token(6)) return true;
33905     if (jj_3R_234()) return true;
33906     return false;
33907   }
33908 
33909   private boolean jj_3R_420() {
33910     if (jj_scan_token(PIPE)) return true;
33911     if (jj_scan_token(ROW)) return true;
33912     if (jj_3R_234()) return true;
33913     return false;
33914   }
33915 
33916   private boolean jj_3R_593() {
33917     if (jj_scan_token(USING)) return true;
33918     Token xsp;
33919     xsp = jj_scanpos;
33920     if (jj_3R_618()) jj_scanpos = xsp;
33921     if (jj_3R_234()) return true;
33922     while (true) {
33923       xsp = jj_scanpos;
33924       if (jj_3R_643()) { jj_scanpos = xsp; break; }
33925     }
33926     return false;
33927   }
33928 
33929   private boolean jj_3R_559() {
33930     Token xsp;
33931     xsp = jj_scanpos;
33932     if (jj_scan_token(237)) {
33933     jj_scanpos = xsp;
33934     if (jj_scan_token(238)) return true;
33935     }
33936     if (jj_scan_token(INTO)) return true;
33937     if (jj_3R_234()) return true;
33938     while (true) {
33939       xsp = jj_scanpos;
33940       if (jj_3R_641()) { jj_scanpos = xsp; break; }
33941     }
33942     return false;
33943   }
33944 
33945   private boolean jj_3R_558() {
33946     if (jj_scan_token(USING)) return true;
33947     Token xsp;
33948     xsp = jj_scanpos;
33949     if (jj_3R_594()) jj_scanpos = xsp;
33950     if (jj_3R_234()) return true;
33951     while (true) {
33952       xsp = jj_scanpos;
33953       if (jj_3R_640()) { jj_scanpos = xsp; break; }
33954     }
33955     return false;
33956   }
33957 
33958   private boolean jj_3R_352() {
33959     if (jj_scan_token(PRAGMA)) return true;
33960     Token xsp;
33961     xsp = jj_scanpos;
33962     if (jj_scan_token(38)) {
33963     jj_scanpos = xsp;
33964     if (jj_scan_token(41)) {
33965     jj_scanpos = xsp;
33966     if (jj_3R_402()) {
33967     jj_scanpos = xsp;
33968     if (jj_3R_403()) {
33969     jj_scanpos = xsp;
33970     if (jj_3R_404()) return true;
33971     }
33972     }
33973     }
33974     }
33975     return false;
33976   }
33977 
33978   private boolean jj_3R_557() {
33979     if (jj_scan_token(INTO)) return true;
33980     if (jj_3R_295()) return true;
33981     Token xsp;
33982     while (true) {
33983       xsp = jj_scanpos;
33984       if (jj_3R_639()) { jj_scanpos = xsp; break; }
33985     }
33986     return false;
33987   }
33988 
33989   private boolean jj_3R_452() {
33990     if (jj_scan_token(WHEN)) return true;
33991     if (jj_3R_234()) return true;
33992     return false;
33993   }
33994 
33995   private boolean jj_3R_419() {
33996     if (jj_scan_token(EXECUTE)) return true;
33997     if (jj_scan_token(IMMEDIATE)) return true;
33998     if (jj_3R_234()) return true;
33999     Token xsp;
34000     xsp = jj_scanpos;
34001     if (jj_3R_557()) jj_scanpos = xsp;
34002     xsp = jj_scanpos;
34003     if (jj_3R_558()) jj_scanpos = xsp;
34004     xsp = jj_scanpos;
34005     if (jj_3R_559()) jj_scanpos = xsp;
34006     if (jj_scan_token(4)) return true;
34007     return false;
34008   }
34009 
34010   private boolean jj_3R_455() {
34011     if (jj_scan_token(FOR)) return true;
34012     if (jj_3R_234()) return true;
34013     Token xsp;
34014     xsp = jj_scanpos;
34015     if (jj_3R_593()) jj_scanpos = xsp;
34016     return false;
34017   }
34018 
34019   private boolean jj_3R_418() {
34020     if (jj_scan_token(FETCH)) return true;
34021     if (jj_3R_128()) return true;
34022     Token xsp;
34023     xsp = jj_scanpos;
34024     if (jj_3R_554()) jj_scanpos = xsp;
34025     if (jj_scan_token(INTO)) return true;
34026     if (jj_3R_234()) return true;
34027     while (true) {
34028       xsp = jj_scanpos;
34029       if (jj_3R_555()) { jj_scanpos = xsp; break; }
34030     }
34031     xsp = jj_scanpos;
34032     if (jj_3R_556()) jj_scanpos = xsp;
34033     return false;
34034   }
34035 
34036   private boolean jj_3R_209() {
34037     if (jj_scan_token(WHEN)) return true;
34038     if (jj_3R_234()) return true;
34039     return false;
34040   }
34041 
34042   private boolean jj_3R_454() {
34043     if (jj_3R_234()) return true;
34044     return false;
34045   }
34046 
34047   private boolean jj_3R_148() {
34048     if (jj_3R_124()) return true;
34049     if (jj_3R_236()) return true;
34050     return false;
34051   }
34052 
34053   private boolean jj_3R_417() {
34054     if (jj_scan_token(OPEN)) return true;
34055     Token xsp;
34056     xsp = jj_scanpos;
34057     if (jj_3R_454()) jj_scanpos = xsp;
34058     xsp = jj_scanpos;
34059     if (jj_3R_455()) jj_scanpos = xsp;
34060     return false;
34061   }
34062 
34063   private boolean jj_3R_453() {
34064     if (jj_3R_128()) return true;
34065     return false;
34066   }
34067 
34068   private boolean jj_3R_416() {
34069     if (jj_scan_token(CLOSE)) return true;
34070     if (jj_3R_128()) return true;
34071     return false;
34072   }
34073 
34074   private boolean jj_3R_451() {
34075     if (jj_3R_143()) return true;
34076     return false;
34077   }
34078 
34079   private boolean jj_3R_415() {
34080     if (jj_scan_token(RAISE)) return true;
34081     Token xsp;
34082     xsp = jj_scanpos;
34083     if (jj_3R_453()) jj_scanpos = xsp;
34084     return false;
34085   }
34086 
34087   private boolean jj_3R_208() {
34088     if (jj_3R_143()) return true;
34089     return false;
34090   }
34091 
34092   private boolean jj_3R_592() {
34093     if (jj_scan_token(12)) return true;
34094     if (jj_3R_234()) return true;
34095     return false;
34096   }
34097 
34098   private boolean jj_3R_414() {
34099     if (jj_scan_token(EXIT)) return true;
34100     Token xsp;
34101     xsp = jj_scanpos;
34102     if (jj_3R_451()) jj_scanpos = xsp;
34103     xsp = jj_scanpos;
34104     if (jj_3R_452()) jj_scanpos = xsp;
34105     return false;
34106   }
34107 
34108   private boolean jj_3R_450() {
34109     if (jj_3R_234()) return true;
34110     return false;
34111   }
34112 
34113   private boolean jj_3R_132() {
34114     if (jj_scan_token(CONTINUE)) return true;
34115     Token xsp;
34116     xsp = jj_scanpos;
34117     if (jj_3R_208()) jj_scanpos = xsp;
34118     xsp = jj_scanpos;
34119     if (jj_3R_209()) jj_scanpos = xsp;
34120     return false;
34121   }
34122 
34123   private boolean jj_3R_552() {
34124     if (jj_scan_token(SAVE)) return true;
34125     if (jj_scan_token(EXCEPTIONS)) return true;
34126     return false;
34127   }
34128 
34129   private boolean jj_3R_551() {
34130     if (jj_3R_234()) return true;
34131     Token xsp;
34132     xsp = jj_scanpos;
34133     if (jj_3R_592()) jj_scanpos = xsp;
34134     return false;
34135   }
34136 
34137   private boolean jj_3R_638() {
34138     if (jj_3R_174()) return true;
34139     return false;
34140   }
34141 
34142   private boolean jj_3R_550() {
34143     Token xsp;
34144     xsp = jj_scanpos;
34145     if (jj_scan_token(140)) {
34146     jj_scanpos = xsp;
34147     if (jj_scan_token(289)) return true;
34148     }
34149     if (jj_scan_token(OF)) return true;
34150     if (jj_3R_234()) return true;
34151     return false;
34152   }
34153 
34154   private boolean jj_3R_413() {
34155     if (jj_scan_token(RETURN)) return true;
34156     Token xsp;
34157     xsp = jj_scanpos;
34158     if (jj_3R_450()) jj_scanpos = xsp;
34159     return false;
34160   }
34161 
34162   private boolean jj_3R_412() {
34163     if (jj_scan_token(GOTO)) return true;
34164     if (jj_3R_128()) return true;
34165     return false;
34166   }
34167 
34168   private boolean jj_3R_356() {
34169     if (jj_scan_token(CASCADE)) return true;
34170     return false;
34171   }
34172 
34173   private boolean jj_3R_315() {
34174     Token xsp;
34175     xsp = jj_scanpos;
34176     if (jj_scan_token(151)) {
34177     jj_scanpos = xsp;
34178     if (jj_3R_356()) return true;
34179     }
34180     return false;
34181   }
34182 
34183   private boolean jj_3R_150() {
34184     if (jj_3R_239()) return true;
34185     return false;
34186   }
34187 
34188   private boolean jj_3R_409() {
34189     if (jj_scan_token(FORALL)) return true;
34190     if (jj_3R_448()) return true;
34191     if (jj_scan_token(IN)) return true;
34192     Token xsp;
34193     xsp = jj_scanpos;
34194     if (jj_3R_550()) {
34195     jj_scanpos = xsp;
34196     if (jj_3R_551()) return true;
34197     }
34198     xsp = jj_scanpos;
34199     if (jj_3R_552()) jj_scanpos = xsp;
34200     if (jj_3R_405()) return true;
34201     return false;
34202   }
34203 
34204   private boolean jj_3_73() {
34205     if (jj_3R_147()) return true;
34206     return false;
34207   }
34208 
34209   private boolean jj_3R_549() {
34210     if (jj_scan_token(12)) return true;
34211     if (jj_3R_234()) return true;
34212     return false;
34213   }
34214 
34215   private boolean jj_3R_149() {
34216     if (jj_scan_token(AUTHID)) return true;
34217     Token xsp;
34218     xsp = jj_scanpos;
34219     if (jj_scan_token(37)) {
34220     jj_scanpos = xsp;
34221     if (jj_scan_token(36)) return true;
34222     }
34223     return false;
34224   }
34225 
34226   private boolean jj_3R_314() {
34227     Token xsp;
34228     xsp = jj_scanpos;
34229     if (jj_scan_token(183)) jj_scanpos = xsp;
34230     xsp = jj_scanpos;
34231     if (jj_scan_token(119)) {
34232     jj_scanpos = xsp;
34233     if (jj_scan_token(145)) {
34234     jj_scanpos = xsp;
34235     if (jj_scan_token(185)) return true;
34236     }
34237     }
34238     return false;
34239   }
34240 
34241   private boolean jj_3_72() {
34242     if (jj_3R_147()) return true;
34243     return false;
34244   }
34245 
34246   private boolean jj_3R_546() {
34247     if (jj_3R_174()) return true;
34248     return false;
34249   }
34250 
34251   private boolean jj_3R_553() {
34252     if (jj_3R_174()) return true;
34253     return false;
34254   }
34255 
34256   private boolean jj_3R_448() {
34257     if (jj_3R_124()) return true;
34258     return false;
34259   }
34260 
34261   private boolean jj_3_71() {
34262     Token xsp;
34263     xsp = jj_scanpos;
34264     if (jj_3R_149()) {
34265     jj_scanpos = xsp;
34266     if (jj_3R_150()) return true;
34267     }
34268     return false;
34269   }
34270 
34271   private boolean jj_3R_313() {
34272     if (jj_scan_token(REPLACE)) return true;
34273     return false;
34274   }
34275 
34276   private boolean jj_3R_447() {
34277     if (jj_3R_124()) return true;
34278     return false;
34279   }
34280 
34281   private boolean jj_3R_548() {
34282     if (jj_3R_486()) return true;
34283     return false;
34284   }
34285 
34286   private boolean jj_3R_547() {
34287     if (jj_3R_591()) return true;
34288     return false;
34289   }
34290 
34291   private boolean jj_3R_407() {
34292     if (jj_scan_token(IF)) return true;
34293     if (jj_3R_234()) return true;
34294     if (jj_scan_token(THEN)) return true;
34295     Token xsp;
34296     if (jj_3R_546()) return true;
34297     while (true) {
34298       xsp = jj_scanpos;
34299       if (jj_3R_546()) { jj_scanpos = xsp; break; }
34300     }
34301     while (true) {
34302       xsp = jj_scanpos;
34303       if (jj_3R_547()) { jj_scanpos = xsp; break; }
34304     }
34305     xsp = jj_scanpos;
34306     if (jj_3R_548()) jj_scanpos = xsp;
34307     if (jj_scan_token(END)) return true;
34308     if (jj_scan_token(IF)) return true;
34309     return false;
34310   }
34311 
34312   private boolean jj_3R_642() {
34313     if (jj_3R_174()) return true;
34314     return false;
34315   }
34316 
34317   private boolean jj_3R_411() {
34318     if (jj_scan_token(WHILE)) return true;
34319     if (jj_3R_234()) return true;
34320     if (jj_scan_token(LOOP)) return true;
34321     Token xsp;
34322     if (jj_3R_553()) return true;
34323     while (true) {
34324       xsp = jj_scanpos;
34325       if (jj_3R_553()) { jj_scanpos = xsp; break; }
34326     }
34327     if (jj_scan_token(END)) return true;
34328     if (jj_scan_token(LOOP)) return true;
34329     xsp = jj_scanpos;
34330     if (jj_scan_token(420)) jj_scanpos = xsp;
34331     return false;
34332   }
34333 
34334   private boolean jj_3R_131() {
34335     if (jj_scan_token(LOCK)) return true;
34336     if (jj_scan_token(TABLE)) return true;
34337     return false;
34338   }
34339 
34340   private boolean jj_3R_408() {
34341     if (jj_scan_token(FOR)) return true;
34342     if (jj_3R_447()) return true;
34343     if (jj_scan_token(IN)) return true;
34344     Token xsp;
34345     xsp = jj_scanpos;
34346     if (jj_scan_token(239)) jj_scanpos = xsp;
34347     if (jj_3R_234()) return true;
34348     xsp = jj_scanpos;
34349     if (jj_3R_549()) jj_scanpos = xsp;
34350     if (jj_scan_token(LOOP)) return true;
34351     if (jj_3R_638()) return true;
34352     while (true) {
34353       xsp = jj_scanpos;
34354       if (jj_3R_638()) { jj_scanpos = xsp; break; }
34355     }
34356     if (jj_scan_token(END)) return true;
34357     if (jj_scan_token(LOOP)) return true;
34358     xsp = jj_scanpos;
34359     if (jj_scan_token(420)) jj_scanpos = xsp;
34360     return false;
34361   }
34362 
34363   private boolean jj_3R_616() {
34364     if (jj_3R_174()) return true;
34365     return false;
34366   }
34367 
34368   private boolean jj_3R_449() {
34369     if (jj_3R_174()) return true;
34370     return false;
34371   }
34372 
34373   private boolean jj_3R_410() {
34374     if (jj_scan_token(LOOP)) return true;
34375     Token xsp;
34376     if (jj_3R_449()) return true;
34377     while (true) {
34378       xsp = jj_scanpos;
34379       if (jj_3R_449()) { jj_scanpos = xsp; break; }
34380     }
34381     if (jj_scan_token(END)) return true;
34382     if (jj_scan_token(LOOP)) return true;
34383     xsp = jj_scanpos;
34384     if (jj_scan_token(420)) jj_scanpos = xsp;
34385     return false;
34386   }
34387 
34388   private boolean jj_3R_130() {
34389     if (jj_scan_token(SET)) return true;
34390     if (jj_scan_token(TRANSACTION)) return true;
34391     return false;
34392   }
34393 
34394   private boolean jj_3R_617() {
34395     if (jj_3R_174()) return true;
34396     return false;
34397   }
34398 
34399   private boolean jj_3R_591() {
34400     if (jj_scan_token(ELSIF)) return true;
34401     if (jj_3R_234()) return true;
34402     if (jj_scan_token(THEN)) return true;
34403     Token xsp;
34404     if (jj_3R_642()) return true;
34405     while (true) {
34406       xsp = jj_scanpos;
34407       if (jj_3R_642()) { jj_scanpos = xsp; break; }
34408     }
34409     return false;
34410   }
34411 
34412   private boolean jj_3R_486() {
34413     if (jj_scan_token(ELSE)) return true;
34414     Token xsp;
34415     if (jj_3R_617()) return true;
34416     while (true) {
34417       xsp = jj_scanpos;
34418       if (jj_3R_617()) { jj_scanpos = xsp; break; }
34419     }
34420     return false;
34421   }
34422 
34423   private boolean jj_3R_485() {
34424     if (jj_scan_token(WHEN)) return true;
34425     if (jj_3R_234()) return true;
34426     if (jj_scan_token(THEN)) return true;
34427     Token xsp;
34428     if (jj_3R_616()) return true;
34429     while (true) {
34430       xsp = jj_scanpos;
34431       if (jj_3R_616()) { jj_scanpos = xsp; break; }
34432     }
34433     return false;
34434   }
34435 
34436   private boolean jj_3R_444() {
34437     if (jj_3R_234()) return true;
34438     return false;
34439   }
34440 
34441   private boolean jj_3R_355() {
34442     if (jj_scan_token(DROP)) return true;
34443     return false;
34444   }
34445 
34446   private boolean jj_3R_446() {
34447     if (jj_3R_486()) return true;
34448     return false;
34449   }
34450 
34451   private boolean jj_3R_445() {
34452     if (jj_3R_485()) return true;
34453     return false;
34454   }
34455 
34456   private boolean jj_3R_406() {
34457     if (jj_scan_token(CASE)) return true;
34458     Token xsp;
34459     xsp = jj_scanpos;
34460     if (jj_3R_444()) jj_scanpos = xsp;
34461     while (true) {
34462       xsp = jj_scanpos;
34463       if (jj_3R_445()) { jj_scanpos = xsp; break; }
34464     }
34465     xsp = jj_scanpos;
34466     if (jj_3R_446()) jj_scanpos = xsp;
34467     if (jj_scan_token(END)) return true;
34468     if (jj_scan_token(CASE)) return true;
34469     xsp = jj_scanpos;
34470     if (jj_scan_token(420)) jj_scanpos = xsp;
34471     return false;
34472   }
34473 
34474   private boolean jj_3R_357() {
34475     if (jj_3R_191()) return true;
34476     return false;
34477   }
34478 
34479   private boolean jj_3R_354() {
34480     Token xsp;
34481     xsp = jj_scanpos;
34482     if (jj_scan_token(6)) jj_scanpos = xsp;
34483     xsp = jj_scanpos;
34484     if (jj_scan_token(44)) {
34485     jj_scanpos = xsp;
34486     if (jj_scan_token(170)) return true;
34487     }
34488     return false;
34489   }
34490 
34491   private boolean jj_3R_312() {
34492     Token xsp;
34493     xsp = jj_scanpos;
34494     if (jj_3R_354()) {
34495     jj_scanpos = xsp;
34496     if (jj_3R_355()) return true;
34497     }
34498     return false;
34499   }
34500 
34501   private boolean jj_3R_316() {
34502     Token xsp;
34503     if (jj_3R_357()) return true;
34504     while (true) {
34505       xsp = jj_scanpos;
34506       if (jj_3R_357()) { jj_scanpos = xsp; break; }
34507     }
34508     if (jj_3R_317()) return true;
34509     return false;
34510   }
34511 
34512   private boolean jj_3R_308() {
34513     if (jj_3R_148()) return true;
34514     return false;
34515   }
34516 
34517   private boolean jj_3R_260() {
34518     if (jj_scan_token(ALTER)) return true;
34519     if (jj_scan_token(TYPE)) return true;
34520     if (jj_3R_128()) return true;
34521     Token xsp;
34522     while (true) {
34523       xsp = jj_scanpos;
34524       if (jj_3R_312()) { jj_scanpos = xsp; break; }
34525     }
34526     xsp = jj_scanpos;
34527     if (jj_3R_313()) jj_scanpos = xsp;
34528     while (true) {
34529       xsp = jj_scanpos;
34530       if (jj_3R_314()) { jj_scanpos = xsp; break; }
34531     }
34532     xsp = jj_scanpos;
34533     if (jj_3R_315()) jj_scanpos = xsp;
34534     return false;
34535   }
34536 
34537   private boolean jj_3_70() {
34538     if (jj_3R_148()) return true;
34539     return false;
34540   }
34541 
34542   private boolean jj_3R_265() {
34543     if (jj_3R_317()) return true;
34544     return false;
34545   }
34546 
34547   private boolean jj_3R_264() {
34548     if (jj_3R_316()) return true;
34549     return false;
34550   }
34551 
34552   private boolean jj_3R_261() {
34553     if (jj_3R_260()) return true;
34554     return false;
34555   }
34556 
34557   private boolean jj_3R_174() {
34558     Token xsp;
34559     xsp = jj_scanpos;
34560     if (jj_3R_264()) {
34561     jj_scanpos = xsp;
34562     if (jj_3R_265()) return true;
34563     }
34564     return false;
34565   }
34566 
34567   private boolean jj_3R_168() {
34568     Token xsp;
34569     xsp = jj_scanpos;
34570     if (jj_scan_token(4)) {
34571     jj_scanpos = xsp;
34572     if (jj_scan_token(1)) return true;
34573     }
34574     while (true) {
34575       xsp = jj_scanpos;
34576       if (jj_3R_261()) { jj_scanpos = xsp; break; }
34577     }
34578     return false;
34579   }
34580 
34581   private boolean jj_3R_167() {
34582     if (jj_3R_260()) return true;
34583     return false;
34584   }
34585 
34586   private boolean jj_3R_377() {
34587     if (jj_3R_234()) return true;
34588     if (jj_scan_token(4)) return true;
34589     return false;
34590   }
34591 
34592   private boolean jj_3R_310() {
34593     if (jj_3R_147()) return true;
34594     return false;
34595   }
34596 
34597   private boolean jj_3R_311() {
34598     if (jj_3R_352()) return true;
34599     return false;
34600   }
34601 
34602   private boolean jj_3R_376() {
34603     if (jj_3R_422()) return true;
34604     if (jj_scan_token(4)) return true;
34605     return false;
34606   }
34607 
34608   private boolean jj_3R_375() {
34609     if (jj_3R_421()) return true;
34610     return false;
34611   }
34612 
34613   private boolean jj_3R_374() {
34614     if (jj_3R_420()) return true;
34615     if (jj_scan_token(4)) return true;
34616     return false;
34617   }
34618 
34619   private boolean jj_3R_373() {
34620     if (jj_3R_419()) return true;
34621     if (jj_scan_token(4)) return true;
34622     return false;
34623   }
34624 
34625   private boolean jj_3R_372() {
34626     if (jj_3R_272()) return true;
34627     if (jj_scan_token(4)) return true;
34628     return false;
34629   }
34630 
34631   private boolean jj_3R_371() {
34632     if (jj_3R_418()) return true;
34633     if (jj_scan_token(4)) return true;
34634     return false;
34635   }
34636 
34637   private boolean jj_3R_443() {
34638     if (jj_scan_token(LOCK)) return true;
34639     if (jj_scan_token(TABLE)) return true;
34640     return false;
34641   }
34642 
34643   private boolean jj_3R_370() {
34644     if (jj_3R_417()) return true;
34645     if (jj_scan_token(4)) return true;
34646     return false;
34647   }
34648 
34649   private boolean jj_3R_166() {
34650     Token xsp;
34651     xsp = jj_scanpos;
34652     if (jj_scan_token(183)) jj_scanpos = xsp;
34653     xsp = jj_scanpos;
34654     if (jj_scan_token(119)) {
34655     jj_scanpos = xsp;
34656     if (jj_scan_token(145)) {
34657     jj_scanpos = xsp;
34658     if (jj_scan_token(185)) return true;
34659     }
34660     }
34661     return false;
34662   }
34663 
34664   private boolean jj_3R_259() {
34665     if (jj_scan_token(6)) return true;
34666     Token xsp;
34667     xsp = jj_scanpos;
34668     if (jj_3R_310()) {
34669     jj_scanpos = xsp;
34670     if (jj_3_70()) {
34671     jj_scanpos = xsp;
34672     if (jj_3R_311()) return true;
34673     }
34674     }
34675     return false;
34676   }
34677 
34678   private boolean jj_3R_369() {
34679     if (jj_3R_416()) return true;
34680     if (jj_scan_token(4)) return true;
34681     return false;
34682   }
34683 
34684   private boolean jj_3R_309() {
34685     if (jj_3R_352()) return true;
34686     return false;
34687   }
34688 
34689   private boolean jj_3R_368() {
34690     if (jj_3R_415()) return true;
34691     if (jj_scan_token(4)) return true;
34692     return false;
34693   }
34694 
34695   private boolean jj_3R_367() {
34696     if (jj_3R_414()) return true;
34697     if (jj_scan_token(4)) return true;
34698     return false;
34699   }
34700 
34701   private boolean jj_3R_366() {
34702     if (jj_3R_413()) return true;
34703     if (jj_scan_token(4)) return true;
34704     return false;
34705   }
34706 
34707   private boolean jj_3_69() {
34708     if (jj_3R_147()) return true;
34709     return false;
34710   }
34711 
34712   private boolean jj_3R_258() {
34713     Token xsp;
34714     xsp = jj_scanpos;
34715     if (jj_3_69()) {
34716     jj_scanpos = xsp;
34717     if (jj_3R_308()) {
34718     jj_scanpos = xsp;
34719     if (jj_3R_309()) return true;
34720     }
34721     }
34722     return false;
34723   }
34724 
34725   private boolean jj_3R_365() {
34726     if (jj_3R_412()) return true;
34727     if (jj_scan_token(4)) return true;
34728     return false;
34729   }
34730 
34731   private boolean jj_3_42() {
34732     Token xsp;
34733     xsp = jj_scanpos;
34734     if (jj_3R_129()) {
34735     jj_scanpos = xsp;
34736     if (jj_scan_token(297)) {
34737     jj_scanpos = xsp;
34738     if (jj_scan_token(144)) {
34739     jj_scanpos = xsp;
34740     if (jj_scan_token(93)) {
34741     jj_scanpos = xsp;
34742     if (jj_scan_token(76)) {
34743     jj_scanpos = xsp;
34744     if (jj_scan_token(241)) {
34745     jj_scanpos = xsp;
34746     if (jj_scan_token(248)) {
34747     jj_scanpos = xsp;
34748     if (jj_scan_token(111)) {
34749     jj_scanpos = xsp;
34750     if (jj_3R_130()) {
34751     jj_scanpos = xsp;
34752     if (jj_3R_131()) {
34753     jj_scanpos = xsp;
34754     if (jj_scan_token(165)) {
34755     jj_scanpos = xsp;
34756     if (jj_scan_token(318)) return true;
34757     }
34758     }
34759     }
34760     }
34761     }
34762     }
34763     }
34764     }
34765     }
34766     }
34767     }
34768     return false;
34769   }
34770 
34771   private boolean jj_3R_129() {
34772     Token xsp;
34773     xsp = jj_scanpos;
34774     if (jj_scan_token(5)) jj_scanpos = xsp;
34775     if (jj_scan_token(SELECT)) return true;
34776     return false;
34777   }
34778 
34779   private boolean jj_3R_364() {
34780     if (jj_3R_411()) return true;
34781     if (jj_scan_token(4)) return true;
34782     return false;
34783   }
34784 
34785   private boolean jj_3R_363() {
34786     if (jj_3R_410()) return true;
34787     if (jj_scan_token(4)) return true;
34788     return false;
34789   }
34790 
34791   private boolean jj_3R_165() {
34792     if (jj_scan_token(5)) return true;
34793     Token xsp;
34794     while (true) {
34795       xsp = jj_scanpos;
34796       if (jj_3R_258()) { jj_scanpos = xsp; break; }
34797     }
34798     while (true) {
34799       xsp = jj_scanpos;
34800       if (jj_3R_259()) { jj_scanpos = xsp; break; }
34801     }
34802     if (jj_scan_token(7)) return true;
34803     return false;
34804   }
34805 
34806   private boolean jj_3R_362() {
34807     if (jj_3R_409()) return true;
34808     if (jj_scan_token(4)) return true;
34809     return false;
34810   }
34811 
34812   private boolean jj_3R_361() {
34813     if (jj_3R_408()) return true;
34814     if (jj_scan_token(4)) return true;
34815     return false;
34816   }
34817 
34818   private boolean jj_3R_360() {
34819     if (jj_3R_407()) return true;
34820     if (jj_scan_token(4)) return true;
34821     return false;
34822   }
34823 
34824   private boolean jj_3R_359() {
34825     if (jj_3R_406()) return true;
34826     if (jj_scan_token(4)) return true;
34827     return false;
34828   }
34829 
34830   private boolean jj_3_43() {
34831     if (jj_3R_132()) return true;
34832     if (jj_scan_token(4)) return true;
34833     return false;
34834   }
34835 
34836   private boolean jj_3R_358() {
34837     if (jj_3R_405()) return true;
34838     Token xsp;
34839     xsp = jj_scanpos;
34840     if (jj_scan_token(4)) jj_scanpos = xsp;
34841     return false;
34842   }
34843 
34844   private boolean jj_3R_604() {
34845     if (jj_3R_124()) return true;
34846     return false;
34847   }
34848 
34849   private boolean jj_3R_317() {
34850     Token xsp;
34851     xsp = jj_scanpos;
34852     if (jj_3R_358()) {
34853     jj_scanpos = xsp;
34854     if (jj_3_43()) {
34855     jj_scanpos = xsp;
34856     if (jj_3R_359()) {
34857     jj_scanpos = xsp;
34858     if (jj_3R_360()) {
34859     jj_scanpos = xsp;
34860     if (jj_3R_361()) {
34861     jj_scanpos = xsp;
34862     if (jj_3R_362()) {
34863     jj_scanpos = xsp;
34864     if (jj_3R_363()) {
34865     jj_scanpos = xsp;
34866     if (jj_3R_364()) {
34867     jj_scanpos = xsp;
34868     if (jj_3R_365()) {
34869     jj_scanpos = xsp;
34870     if (jj_3R_366()) {
34871     jj_scanpos = xsp;
34872     if (jj_3R_367()) {
34873     jj_scanpos = xsp;
34874     if (jj_3R_368()) {
34875     jj_scanpos = xsp;
34876     if (jj_3R_369()) {
34877     jj_scanpos = xsp;
34878     if (jj_3R_370()) {
34879     jj_scanpos = xsp;
34880     if (jj_3R_371()) {
34881     jj_scanpos = xsp;
34882     if (jj_3R_372()) {
34883     jj_scanpos = xsp;
34884     if (jj_3R_373()) {
34885     jj_scanpos = xsp;
34886     if (jj_3R_374()) {
34887     jj_scanpos = xsp;
34888     if (jj_3R_375()) {
34889     jj_scanpos = xsp;
34890     if (jj_3R_376()) {
34891     jj_scanpos = xsp;
34892     if (jj_3R_377()) return true;
34893     }
34894     }
34895     }
34896     }
34897     }
34898     }
34899     }
34900     }
34901     }
34902     }
34903     }
34904     }
34905     }
34906     }
34907     }
34908     }
34909     }
34910     }
34911     }
34912     }
34913     return false;
34914   }
34915 
34916   private boolean jj_3R_164() {
34917     if (jj_3R_249()) return true;
34918     return false;
34919   }
34920 
34921   private boolean jj_3R_442() {
34922     if (jj_scan_token(SET)) return true;
34923     if (jj_scan_token(TRANSACTION)) return true;
34924     return false;
34925   }
34926 
34927   private boolean jj_3_67() {
34928     Token xsp;
34929     xsp = jj_scanpos;
34930     if (jj_scan_token(152)) {
34931     jj_scanpos = xsp;
34932     if (jj_scan_token(51)) return true;
34933     }
34934     if (jj_3R_146()) return true;
34935     if (jj_scan_token(OF)) return true;
34936     if (jj_3R_236()) return true;
34937     return false;
34938   }
34939 
34940   private boolean jj_3R_145() {
34941     if (jj_3R_239()) return true;
34942     return false;
34943   }
34944 
34945   private boolean jj_3_66() {
34946     Token xsp;
34947     xsp = jj_scanpos;
34948     if (jj_scan_token(152)) {
34949     jj_scanpos = xsp;
34950     if (jj_scan_token(51)) return true;
34951     }
34952     if (jj_scan_token(OPAQUE)) return true;
34953     if (jj_scan_token(VARYING)) return true;
34954     if (jj_scan_token(24)) return true;
34955     return false;
34956   }
34957 
34958   private boolean jj_3_68() {
34959     if (jj_scan_token(EXTERNAL)) return true;
34960     if (jj_scan_token(IDENTIFIER)) return true;
34961     if (jj_scan_token(IDENTIFIER)) return true;
34962     if (jj_scan_token(LANGUAGE)) return true;
34963     if (jj_scan_token(JAVA)) return true;
34964     if (jj_scan_token(USING)) return true;
34965     if (jj_scan_token(IDENTIFIER)) return true;
34966     return false;
34967   }
34968 
34969   private boolean jj_3_65() {
34970     Token xsp;
34971     xsp = jj_scanpos;
34972     if (jj_scan_token(152)) {
34973     jj_scanpos = xsp;
34974     if (jj_scan_token(51)) return true;
34975     }
34976     if (jj_scan_token(OBJECT)) return true;
34977     return false;
34978   }
34979 
34980   private boolean jj_3R_144() {
34981     if (jj_scan_token(AUTHID)) return true;
34982     Token xsp;
34983     xsp = jj_scanpos;
34984     if (jj_scan_token(37)) {
34985     jj_scanpos = xsp;
34986     if (jj_scan_token(36)) return true;
34987     }
34988     return false;
34989   }
34990 
34991   private boolean jj_3R_257() {
34992     if (jj_scan_token(UNDER)) return true;
34993     if (jj_3R_155()) return true;
34994     return false;
34995   }
34996 
34997   private boolean jj_3R_163() {
34998     Token xsp;
34999     xsp = jj_scanpos;
35000     if (jj_3R_257()) {
35001     jj_scanpos = xsp;
35002     if (jj_3_65()) {
35003     jj_scanpos = xsp;
35004     if (jj_3_66()) {
35005     jj_scanpos = xsp;
35006     if (jj_3_67()) return true;
35007     }
35008     }
35009     }
35010     return false;
35011   }
35012 
35013   private boolean jj_3R_256() {
35014     Token xsp;
35015     xsp = jj_scanpos;
35016     if (jj_scan_token(100)) {
35017     jj_scanpos = xsp;
35018     if (jj_scan_token(182)) return true;
35019     }
35020     return false;
35021   }
35022 
35023   private boolean jj_3R_249() {
35024     if (jj_scan_token(WRAPPED)) return true;
35025     return false;
35026   }
35027 
35028   private boolean jj_3R_603() {
35029     if (jj_3R_351()) return true;
35030     return false;
35031   }
35032 
35033   private boolean jj_3_64() {
35034     Token xsp;
35035     xsp = jj_scanpos;
35036     if (jj_3R_144()) {
35037     jj_scanpos = xsp;
35038     if (jj_3R_145()) return true;
35039     }
35040     return false;
35041   }
35042 
35043   private boolean jj_3_63() {
35044     if (jj_scan_token(OID)) return true;
35045     if (jj_scan_token(STRING_LITERAL)) return true;
35046     return false;
35047   }
35048 
35049   private boolean jj_3R_255() {
35050     if (jj_scan_token(OR)) return true;
35051     if (jj_scan_token(REPLACE)) return true;
35052     return false;
35053   }
35054 
35055   private boolean jj_3R_602() {
35056     if (jj_3R_174()) return true;
35057     return false;
35058   }
35059 
35060   private boolean jj_3R_162() {
35061     if (jj_scan_token(CREATE)) return true;
35062     Token xsp;
35063     xsp = jj_scanpos;
35064     if (jj_3R_255()) jj_scanpos = xsp;
35065     xsp = jj_scanpos;
35066     if (jj_3R_256()) jj_scanpos = xsp;
35067     return false;
35068   }
35069 
35070   private boolean jj_3R_105() {
35071     Token xsp;
35072     xsp = jj_scanpos;
35073     if (jj_3R_162()) jj_scanpos = xsp;
35074     if (jj_scan_token(TYPE)) return true;
35075     if (jj_3R_155()) return true;
35076     xsp = jj_scanpos;
35077     if (jj_scan_token(123)) jj_scanpos = xsp;
35078     xsp = jj_scanpos;
35079     if (jj_3_63()) jj_scanpos = xsp;
35080     while (true) {
35081       xsp = jj_scanpos;
35082       if (jj_3_64()) { jj_scanpos = xsp; break; }
35083     }
35084     xsp = jj_scanpos;
35085     if (jj_3R_163()) jj_scanpos = xsp;
35086     xsp = jj_scanpos;
35087     if (jj_3_68()) jj_scanpos = xsp;
35088     xsp = jj_scanpos;
35089     if (jj_3R_164()) jj_scanpos = xsp;
35090     xsp = jj_scanpos;
35091     if (jj_3R_165()) jj_scanpos = xsp;
35092     while (true) {
35093       xsp = jj_scanpos;
35094       if (jj_3R_166()) { jj_scanpos = xsp; break; }
35095     }
35096     while (true) {
35097       xsp = jj_scanpos;
35098       if (jj_3R_167()) { jj_scanpos = xsp; break; }
35099     }
35100     xsp = jj_scanpos;
35101     if (jj_3R_168()) jj_scanpos = xsp;
35102     return false;
35103   }
35104 
35105   private boolean jj_3R_568() {
35106     if (jj_3R_192()) return true;
35107     if (jj_scan_token(BEGIN)) return true;
35108     Token xsp;
35109     while (true) {
35110       xsp = jj_scanpos;
35111       if (jj_3R_602()) { jj_scanpos = xsp; break; }
35112     }
35113     xsp = jj_scanpos;
35114     if (jj_3R_603()) jj_scanpos = xsp;
35115     if (jj_scan_token(END)) return true;
35116     xsp = jj_scanpos;
35117     if (jj_3R_604()) jj_scanpos = xsp;
35118     if (jj_scan_token(4)) return true;
35119     return false;
35120   }
35121 
35122   private boolean jj_3R_567() {
35123     if (jj_3R_123()) return true;
35124     Token xsp;
35125     xsp = jj_scanpos;
35126     if (jj_scan_token(4)) jj_scanpos = xsp;
35127     return false;
35128   }
35129 
35130   private boolean jj_3R_531() {
35131     Token xsp;
35132     xsp = jj_scanpos;
35133     if (jj_scan_token(152)) {
35134     jj_scanpos = xsp;
35135     if (jj_scan_token(51)) return true;
35136     }
35137     xsp = jj_scanpos;
35138     if (jj_3R_567()) {
35139     jj_scanpos = xsp;
35140     if (jj_3R_568()) return true;
35141     }
35142     return false;
35143   }
35144 
35145   private boolean jj_3R_405() {
35146     Token xsp;
35147     xsp = jj_scanpos;
35148     if (jj_scan_token(250)) {
35149     jj_scanpos = xsp;
35150     if (jj_scan_token(297)) {
35151     jj_scanpos = xsp;
35152     if (jj_scan_token(144)) {
35153     jj_scanpos = xsp;
35154     if (jj_scan_token(93)) {
35155     jj_scanpos = xsp;
35156     if (jj_scan_token(76)) {
35157     jj_scanpos = xsp;
35158     if (jj_scan_token(241)) {
35159     jj_scanpos = xsp;
35160     if (jj_scan_token(248)) {
35161     jj_scanpos = xsp;
35162     if (jj_scan_token(111)) {
35163     jj_scanpos = xsp;
35164     if (jj_3R_442()) {
35165     jj_scanpos = xsp;
35166     if (jj_3R_443()) {
35167     jj_scanpos = xsp;
35168     if (jj_scan_token(165)) {
35169     jj_scanpos = xsp;
35170     if (jj_scan_token(318)) return true;
35171     }
35172     }
35173     }
35174     }
35175     }
35176     }
35177     }
35178     }
35179     }
35180     }
35181     }
35182     if (jj_3R_180()) return true;
35183     return false;
35184   }
35185 
35186   private boolean jj_3_61() {
35187     if (jj_3R_124()) return true;
35188     if (jj_scan_token(3)) return true;
35189     return false;
35190   }
35191 
35192   private boolean jj_3R_491() {
35193     return false;
35194   }
35195 
35196   private boolean jj_3R_242() {
35197     Token xsp;
35198     xsp = jj_scanpos;
35199     if (jj_scan_token(162)) {
35200     jj_scanpos = xsp;
35201     if (jj_scan_token(204)) return true;
35202     }
35203     return false;
35204   }
35205 
35206   private boolean jj_3R_241() {
35207     Token xsp;
35208     xsp = jj_scanpos;
35209     if (jj_scan_token(183)) jj_scanpos = xsp;
35210     xsp = jj_scanpos;
35211     if (jj_scan_token(208)) {
35212     jj_scanpos = xsp;
35213     if (jj_scan_token(145)) {
35214     jj_scanpos = xsp;
35215     if (jj_scan_token(119)) return true;
35216     }
35217     }
35218     return false;
35219   }
35220 
35221   private boolean jj_3_62() {
35222     if (jj_3R_124()) return true;
35223     if (jj_scan_token(3)) return true;
35224     if (jj_3R_124()) return true;
35225     if (jj_scan_token(3)) return true;
35226     if (jj_3R_124()) return true;
35227     return false;
35228   }
35229 
35230   private boolean jj_3R_147() {
35231     Token xsp;
35232     while (true) {
35233       xsp = jj_scanpos;
35234       if (jj_3R_241()) { jj_scanpos = xsp; break; }
35235     }
35236     xsp = jj_scanpos;
35237     if (jj_3R_242()) jj_scanpos = xsp;
35238     xsp = jj_scanpos;
35239     if (jj_scan_token(80)) {
35240     jj_scanpos = xsp;
35241     if (jj_scan_token(164)) {
35242     jj_scanpos = xsp;
35243     if (jj_scan_token(262)) return true;
35244     }
35245     }
35246     if (jj_3R_194()) return true;
35247     xsp = jj_scanpos;
35248     if (jj_scan_token(95)) jj_scanpos = xsp;
35249     xsp = jj_scanpos;
35250     if (jj_scan_token(210)) jj_scanpos = xsp;
35251     xsp = jj_scanpos;
35252     if (jj_scan_token(214)) jj_scanpos = xsp;
35253     xsp = jj_scanpos;
35254     if (jj_scan_token(236)) jj_scanpos = xsp;
35255     xsp = jj_scanpos;
35256     if (jj_3R_531()) jj_scanpos = xsp;
35257     return false;
35258   }
35259 
35260   private boolean jj_3R_188() {
35261     return false;
35262   }
35263 
35264   private boolean jj_3R_262() {
35265     if (jj_3R_124()) return true;
35266     return false;
35267   }
35268 
35269   private boolean jj_3R_190() {
35270     return false;
35271   }
35272 
35273   private boolean jj_3R_185() {
35274     if (jj_3R_143()) return true;
35275     if (jj_scan_token(IDENTIFIED)) return true;
35276     return false;
35277   }
35278 
35279   private boolean jj_3R_184() {
35280     if (jj_scan_token(CONNECT)) return true;
35281     if (jj_scan_token(TO)) return true;
35282     return false;
35283   }
35284 
35285   private boolean jj_3R_112() {
35286     if (jj_scan_token(CREATE)) return true;
35287     Token xsp;
35288     xsp = jj_scanpos;
35289     if (jj_scan_token(410)) jj_scanpos = xsp;
35290     xsp = jj_scanpos;
35291     if (jj_scan_token(224)) jj_scanpos = xsp;
35292     if (jj_scan_token(DATABASE)) return true;
35293     if (jj_scan_token(LINK)) return true;
35294     if (jj_3R_155()) return true;
35295     xsp = jj_scanpos;
35296     if (jj_3R_184()) {
35297     jj_scanpos = xsp;
35298     if (jj_3R_185()) return true;
35299     }
35300     return false;
35301   }
35302 
35303   private boolean jj_3R_459() {
35304     if (jj_3R_174()) return true;
35305     return false;
35306   }
35307 
35308   private boolean jj_3R_182() {
35309     if (jj_scan_token(OR)) return true;
35310     if (jj_scan_token(REPLACE)) return true;
35311     return false;
35312   }
35313 
35314   private boolean jj_3R_111() {
35315     if (jj_scan_token(CREATE)) return true;
35316     Token xsp;
35317     xsp = jj_scanpos;
35318     if (jj_3R_182()) jj_scanpos = xsp;
35319     if (jj_scan_token(DIRECTORY)) return true;
35320     if (jj_3R_155()) return true;
35321     if (jj_scan_token(AS)) return true;
35322     if (jj_3R_183()) return true;
35323     xsp = jj_scanpos;
35324     if (jj_scan_token(4)) {
35325     jj_scanpos = xsp;
35326     if (jj_scan_token(1)) return true;
35327     }
35328     return false;
35329   }
35330 
35331   private boolean jj_3R_181() {
35332     if (jj_scan_token(OR)) return true;
35333     if (jj_scan_token(REPLACE)) return true;
35334     return false;
35335   }
35336 
35337   private boolean jj_3R_564() {
35338     return false;
35339   }
35340 
35341   private boolean jj_3R_263() {
35342     if (jj_scan_token(6)) return true;
35343     return false;
35344   }
35345 
35346   private boolean jj_3R_110() {
35347     if (jj_scan_token(CREATE)) return true;
35348     Token xsp;
35349     xsp = jj_scanpos;
35350     if (jj_3R_181()) jj_scanpos = xsp;
35351     xsp = jj_scanpos;
35352     if (jj_scan_token(224)) jj_scanpos = xsp;
35353     if (jj_scan_token(SYNONYM)) return true;
35354     if (jj_3R_155()) return true;
35355     if (jj_scan_token(FOR)) return true;
35356     if (jj_3R_155()) return true;
35357     xsp = jj_scanpos;
35358     if (jj_scan_token(4)) {
35359     jj_scanpos = xsp;
35360     if (jj_scan_token(1)) return true;
35361     }
35362     return false;
35363   }
35364 
35365   private boolean jj_3R_458() {
35366     if (jj_scan_token(OR)) return true;
35367     if (jj_3R_128()) return true;
35368     return false;
35369   }
35370 
35371   private boolean jj_3R_171() {
35372     if (jj_scan_token(OR)) return true;
35373     if (jj_scan_token(REPLACE)) return true;
35374     return false;
35375   }
35376 
35377   private boolean jj_3R_173() {
35378     if (jj_scan_token(5)) return true;
35379     if (jj_3R_262()) return true;
35380     Token xsp;
35381     while (true) {
35382       xsp = jj_scanpos;
35383       if (jj_3R_263()) { jj_scanpos = xsp; break; }
35384     }
35385     if (jj_scan_token(7)) return true;
35386     return false;
35387   }
35388 
35389   private boolean jj_3R_172() {
35390     Token xsp;
35391     xsp = jj_scanpos;
35392     if (jj_scan_token(179)) jj_scanpos = xsp;
35393     if (jj_scan_token(FORCE)) return true;
35394     return false;
35395   }
35396 
35397   private boolean jj_3R_460() {
35398     if (jj_3R_174()) return true;
35399     return false;
35400   }
35401 
35402   private boolean jj_3R_107() {
35403     if (jj_scan_token(CREATE)) return true;
35404     Token xsp;
35405     xsp = jj_scanpos;
35406     if (jj_3R_171()) jj_scanpos = xsp;
35407     xsp = jj_scanpos;
35408     if (jj_3R_172()) jj_scanpos = xsp;
35409     if (jj_scan_token(VIEW)) return true;
35410     if (jj_3R_155()) return true;
35411     xsp = jj_scanpos;
35412     if (jj_3R_173()) jj_scanpos = xsp;
35413     if (jj_scan_token(AS)) return true;
35414     if (jj_3R_174()) return true;
35415     xsp = jj_scanpos;
35416     if (jj_scan_token(4)) {
35417     jj_scanpos = xsp;
35418     if (jj_scan_token(1)) return true;
35419     }
35420     return false;
35421   }
35422 
35423   private boolean jj_3R_180() {
35424     return false;
35425   }
35426 
35427   private boolean jj_3R_170() {
35428     if (jj_3R_124()) return true;
35429     if (jj_3R_236()) return true;
35430     return false;
35431   }
35432 
35433   private boolean jj_3R_629() {
35434     if (jj_scan_token(6)) return true;
35435     if (jj_3R_124()) return true;
35436     return false;
35437   }
35438 
35439   private boolean jj_3R_628() {
35440     if (jj_scan_token(6)) return true;
35441     if (jj_3R_124()) return true;
35442     return false;
35443   }
35444 
35445   private boolean jj_3R_169() {
35446     if (jj_scan_token(GLOBAL)) return true;
35447     if (jj_scan_token(TEMPORARY)) return true;
35448     return false;
35449   }
35450 
35451   private boolean jj_3_60() {
35452     if (jj_scan_token(ON)) return true;
35453     if (jj_scan_token(COMMIT)) return true;
35454     return false;
35455   }
35456 
35457   private boolean jj_3R_401() {
35458     if (jj_scan_token(WHEN)) return true;
35459     if (jj_scan_token(OTHERS)) return true;
35460     if (jj_scan_token(THEN)) return true;
35461     Token xsp;
35462     if (jj_3R_460()) return true;
35463     while (true) {
35464       xsp = jj_scanpos;
35465       if (jj_3R_460()) { jj_scanpos = xsp; break; }
35466     }
35467     return false;
35468   }
35469 
35470   private boolean jj_3_41() {
35471     if (jj_scan_token(WHEN)) return true;
35472     if (jj_3R_128()) return true;
35473     Token xsp;
35474     while (true) {
35475       xsp = jj_scanpos;
35476       if (jj_3R_458()) { jj_scanpos = xsp; break; }
35477     }
35478     if (jj_scan_token(THEN)) return true;
35479     if (jj_3R_459()) return true;
35480     while (true) {
35481       xsp = jj_scanpos;
35482       if (jj_3R_459()) { jj_scanpos = xsp; break; }
35483     }
35484     return false;
35485   }
35486 
35487   private boolean jj_3R_106() {
35488     if (jj_scan_token(CREATE)) return true;
35489     Token xsp;
35490     xsp = jj_scanpos;
35491     if (jj_3R_169()) jj_scanpos = xsp;
35492     if (jj_scan_token(TABLE)) return true;
35493     if (jj_3R_155()) return true;
35494     if (jj_scan_token(5)) return true;
35495     if (jj_3R_170()) return true;
35496     return false;
35497   }
35498 
35499   private boolean jj_3R_621() {
35500     Token xsp;
35501     xsp = jj_scanpos;
35502     if (jj_scan_token(125)) {
35503     jj_scanpos = xsp;
35504     if (jj_scan_token(223)) {
35505     jj_scanpos = xsp;
35506     if (jj_scan_token(209)) {
35507     jj_scanpos = xsp;
35508     if (jj_scan_token(282)) {
35509     jj_scanpos = xsp;
35510     if (jj_scan_token(284)) return true;
35511     }
35512     }
35513     }
35514     }
35515     return false;
35516   }
35517 
35518   private boolean jj_3R_351() {
35519     if (jj_scan_token(EXCEPTION)) return true;
35520     Token xsp;
35521     while (true) {
35522       xsp = jj_scanpos;
35523       if (jj_3_41()) { jj_scanpos = xsp; break; }
35524     }
35525     xsp = jj_scanpos;
35526     if (jj_3R_401()) jj_scanpos = xsp;
35527     return false;
35528   }
35529 
35530   private boolean jj_3R_349() {
35531     Token xsp;
35532     xsp = jj_scanpos;
35533     if (jj_scan_token(125)) {
35534     jj_scanpos = xsp;
35535     if (jj_scan_token(223)) {
35536     jj_scanpos = xsp;
35537     if (jj_scan_token(209)) {
35538     jj_scanpos = xsp;
35539     if (jj_scan_token(282)) {
35540     jj_scanpos = xsp;
35541     if (jj_scan_token(284)) return true;
35542     }
35543     }
35544     }
35545     }
35546     return false;
35547   }
35548 
35549   private boolean jj_3R_350() {
35550     if (jj_scan_token(6)) return true;
35551     Token xsp;
35552     xsp = jj_scanpos;
35553     if (jj_3R_621()) jj_scanpos = xsp;
35554     if (jj_3R_128()) return true;
35555     return false;
35556   }
35557 
35558   private boolean jj_3R_490() {
35559     if (jj_scan_token(6)) return true;
35560     if (jj_3R_127()) return true;
35561     return false;
35562   }
35563 
35564   private boolean jj_3R_489() {
35565     Token xsp;
35566     xsp = jj_scanpos;
35567     if (jj_scan_token(16)) {
35568     jj_scanpos = xsp;
35569     if (jj_scan_token(17)) return true;
35570     }
35571     return false;
35572   }
35573 
35574   private boolean jj_3R_239() {
35575     if (jj_scan_token(ACCESSIBLE)) return true;
35576     if (jj_scan_token(BY)) return true;
35577     if (jj_scan_token(5)) return true;
35578     Token xsp;
35579     xsp = jj_scanpos;
35580     if (jj_3R_349()) jj_scanpos = xsp;
35581     if (jj_3R_128()) return true;
35582     while (true) {
35583       xsp = jj_scanpos;
35584       if (jj_3R_350()) { jj_scanpos = xsp; break; }
35585     }
35586     if (jj_scan_token(7)) return true;
35587     return false;
35588   }
35589 
35590   private boolean jj_3R_622() {
35591     Token xsp;
35592     xsp = jj_scanpos;
35593     if (jj_scan_token(130)) {
35594     jj_scanpos = xsp;
35595     if (jj_scan_token(226)) return true;
35596     }
35597     if (jj_scan_token(5)) return true;
35598     if (jj_3R_124()) return true;
35599     while (true) {
35600       xsp = jj_scanpos;
35601       if (jj_3R_628()) { jj_scanpos = xsp; break; }
35602     }
35603     if (jj_scan_token(7)) return true;
35604     return false;
35605   }
35606 
35607   private boolean jj_3_40() {
35608     if (jj_scan_token(5)) return true;
35609     if (jj_3R_127()) return true;
35610     if (jj_scan_token(7)) return true;
35611     return false;
35612   }
35613 
35614   private boolean jj_3R_623() {
35615     Token xsp;
35616     xsp = jj_scanpos;
35617     if (jj_scan_token(204)) {
35618     jj_scanpos = xsp;
35619     if (jj_scan_token(71)) return true;
35620     }
35621     if (jj_scan_token(BY)) return true;
35622     if (jj_scan_token(5)) return true;
35623     if (jj_3R_124()) return true;
35624     while (true) {
35625       xsp = jj_scanpos;
35626       if (jj_3R_629()) { jj_scanpos = xsp; break; }
35627     }
35628     if (jj_scan_token(7)) return true;
35629     return false;
35630   }
35631 
35632   private boolean jj_3R_481() {
35633     if (jj_scan_token(TO)) return true;
35634     Token xsp;
35635     xsp = jj_scanpos;
35636     if (jj_scan_token(316)) {
35637     jj_scanpos = xsp;
35638     if (jj_scan_token(173)) {
35639     jj_scanpos = xsp;
35640     if (jj_scan_token(89)) {
35641     jj_scanpos = xsp;
35642     if (jj_scan_token(133)) {
35643     jj_scanpos = xsp;
35644     if (jj_scan_token(168)) {
35645     jj_scanpos = xsp;
35646     if (jj_scan_token(249)) return true;
35647     }
35648     }
35649     }
35650     }
35651     }
35652     xsp = jj_scanpos;
35653     if (jj_3_40()) jj_scanpos = xsp;
35654     return false;
35655   }
35656 
35657   private boolean jj_3R_507() {
35658     if (jj_scan_token(LOCAL)) return true;
35659     return false;
35660   }
35661 
35662   private boolean jj_3R_429() {
35663     if (jj_scan_token(5)) return true;
35664     if (jj_scan_token(PARTITION)) return true;
35665     if (jj_3R_124()) return true;
35666     if (jj_scan_token(BY)) return true;
35667     Token xsp;
35668     xsp = jj_scanpos;
35669     if (jj_scan_token(49)) {
35670     jj_scanpos = xsp;
35671     if (jj_3R_622()) return true;
35672     }
35673     if (jj_scan_token(7)) return true;
35674     xsp = jj_scanpos;
35675     if (jj_3R_623()) jj_scanpos = xsp;
35676     return false;
35677   }
35678 
35679   private boolean jj_3R_480() {
35680     if (jj_scan_token(WITH)) return true;
35681     Token xsp;
35682     xsp = jj_scanpos;
35683     if (jj_3R_507()) jj_scanpos = xsp;
35684     if (jj_scan_token(TIME)) return true;
35685     if (jj_scan_token(ZONE)) return true;
35686     return false;
35687   }
35688 
35689   private boolean jj_3R_435() {
35690     Token xsp;
35691     xsp = jj_scanpos;
35692     if (jj_3R_480()) {
35693     jj_scanpos = xsp;
35694     if (jj_3R_481()) return true;
35695     }
35696     return false;
35697   }
35698 
35699   private boolean jj_3R_119() {
35700     if (jj_3R_124()) return true;
35701     if (jj_scan_token(EXCEPTION)) return true;
35702     if (jj_scan_token(4)) return true;
35703     return false;
35704   }
35705 
35706   private boolean jj_3_39() {
35707     if (jj_scan_token(5)) return true;
35708     if (jj_3R_127()) return true;
35709     if (jj_scan_token(7)) return true;
35710     return false;
35711   }
35712 
35713   private boolean jj_3R_519() {
35714     if (jj_3R_183()) return true;
35715     return false;
35716   }
35717 
35718   private boolean jj_3R_422() {
35719     if (jj_scan_token(PRAGMA)) return true;
35720     if (jj_scan_token(INLINE)) return true;
35721     if (jj_scan_token(5)) return true;
35722     if (jj_3R_128()) return true;
35723     if (jj_scan_token(6)) return true;
35724     if (jj_3R_183()) return true;
35725     if (jj_scan_token(7)) return true;
35726     return false;
35727   }
35728 
35729   private boolean jj_3R_518() {
35730     if (jj_3R_124()) return true;
35731     return false;
35732   }
35733 
35734   private boolean jj_3R_469() {
35735     if (jj_3R_128()) return true;
35736     if (jj_scan_token(5)) return true;
35737     if (jj_3R_491()) return true;
35738     return false;
35739   }
35740 
35741   private boolean jj_3R_468() {
35742     if (jj_scan_token(INTERFACE)) return true;
35743     if (jj_scan_token(5)) return true;
35744     if (jj_scan_token(IDENTIFIER)) return true;
35745     if (jj_scan_token(6)) return true;
35746     if (jj_3R_124()) return true;
35747     Token xsp;
35748     xsp = jj_scanpos;
35749     if (jj_3R_490()) jj_scanpos = xsp;
35750     if (jj_scan_token(7)) return true;
35751     return false;
35752   }
35753 
35754   private boolean jj_3R_434() {
35755     Token xsp;
35756     xsp = jj_scanpos;
35757     if (jj_scan_token(316)) {
35758     jj_scanpos = xsp;
35759     if (jj_scan_token(173)) {
35760     jj_scanpos = xsp;
35761     if (jj_scan_token(89)) {
35762     jj_scanpos = xsp;
35763     if (jj_scan_token(133)) {
35764     jj_scanpos = xsp;
35765     if (jj_scan_token(168)) {
35766     jj_scanpos = xsp;
35767     if (jj_scan_token(249)) return true;
35768     }
35769     }
35770     }
35771     }
35772     }
35773     return false;
35774   }
35775 
35776   private boolean jj_3R_467() {
35777     if (jj_scan_token(EXCEPTION_INIT)) return true;
35778     if (jj_scan_token(5)) return true;
35779     if (jj_scan_token(IDENTIFIER)) return true;
35780     if (jj_scan_token(6)) return true;
35781     Token xsp;
35782     xsp = jj_scanpos;
35783     if (jj_3R_489()) jj_scanpos = xsp;
35784     if (jj_3R_127()) return true;
35785     if (jj_scan_token(7)) return true;
35786     return false;
35787   }
35788 
35789   private boolean jj_3R_488() {
35790     if (jj_scan_token(6)) return true;
35791     Token xsp;
35792     xsp = jj_scanpos;
35793     if (jj_3R_518()) {
35794     jj_scanpos = xsp;
35795     if (jj_3R_519()) return true;
35796     }
35797     return false;
35798   }
35799 
35800   private boolean jj_3R_433() {
35801     if (jj_3R_183()) return true;
35802     return false;
35803   }
35804 
35805   private boolean jj_3R_466() {
35806     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35807     if (jj_scan_token(5)) return true;
35808     if (jj_3R_124()) return true;
35809     Token xsp;
35810     if (jj_3R_488()) return true;
35811     while (true) {
35812       xsp = jj_scanpos;
35813       if (jj_3R_488()) { jj_scanpos = xsp; break; }
35814     }
35815     if (jj_scan_token(7)) return true;
35816     return false;
35817   }
35818 
35819   private boolean jj_3R_432() {
35820     if (jj_scan_token(CHARACTER_LITERAL)) return true;
35821     return false;
35822   }
35823 
35824   private boolean jj_3R_465() {
35825     if (jj_scan_token(TIMESTAMP)) return true;
35826     if (jj_scan_token(5)) return true;
35827     if (jj_3R_183()) return true;
35828     if (jj_scan_token(7)) return true;
35829     return false;
35830   }
35831 
35832   private boolean jj_3R_423() {
35833     if (jj_scan_token(PRAGMA)) return true;
35834     Token xsp;
35835     xsp = jj_scanpos;
35836     if (jj_scan_token(38)) {
35837     jj_scanpos = xsp;
35838     if (jj_scan_token(41)) {
35839     jj_scanpos = xsp;
35840     if (jj_3R_465()) {
35841     jj_scanpos = xsp;
35842     if (jj_3R_466()) {
35843     jj_scanpos = xsp;
35844     if (jj_3R_467()) {
35845     jj_scanpos = xsp;
35846     if (jj_3R_468()) {
35847     jj_scanpos = xsp;
35848     if (jj_3R_469()) return true;
35849     }
35850     }
35851     }
35852     }
35853     }
35854     }
35855     if (jj_scan_token(4)) return true;
35856     return false;
35857   }
35858 
35859   private boolean jj_3_34() {
35860     if (jj_scan_token(5)) return true;
35861     if (jj_3R_127()) return true;
35862     if (jj_scan_token(7)) return true;
35863     return false;
35864   }
35865 
35866   private boolean jj_3R_393() {
35867     Token xsp;
35868     xsp = jj_scanpos;
35869     if (jj_scan_token(149)) {
35870     jj_scanpos = xsp;
35871     if (jj_scan_token(275)) {
35872     jj_scanpos = xsp;
35873     if (jj_scan_token(88)) return true;
35874     }
35875     }
35876     xsp = jj_scanpos;
35877     if (jj_3R_432()) {
35878     jj_scanpos = xsp;
35879     if (jj_3R_433()) return true;
35880     }
35881     xsp = jj_scanpos;
35882     if (jj_3R_434()) jj_scanpos = xsp;
35883     xsp = jj_scanpos;
35884     if (jj_3_39()) jj_scanpos = xsp;
35885     xsp = jj_scanpos;
35886     if (jj_3R_435()) jj_scanpos = xsp;
35887     return false;
35888   }
35889 
35890   private boolean jj_3R_121() {
35891     if (jj_3R_198()) return true;
35892     if (jj_scan_token(4)) return true;
35893     return false;
35894   }
35895 
35896   private boolean jj_3_38() {
35897     if (jj_scan_token(TO)) return true;
35898     if (jj_scan_token(SECOND)) return true;
35899     Token xsp;
35900     xsp = jj_scanpos;
35901     if (jj_3_34()) jj_scanpos = xsp;
35902     return false;
35903   }
35904 
35905   private boolean jj_3R_569() {
35906     if (jj_scan_token(USING)) return true;
35907     Token xsp;
35908     xsp = jj_scanpos;
35909     if (jj_scan_token(401)) {
35910     jj_scanpos = xsp;
35911     if (jj_scan_token(402)) return true;
35912     }
35913     return false;
35914   }
35915 
35916   private boolean jj_3_37() {
35917     if (jj_scan_token(TO)) return true;
35918     if (jj_scan_token(MONTH)) return true;
35919     return false;
35920   }
35921 
35922   private boolean jj_3_36() {
35923     if (jj_scan_token(WITH)) return true;
35924     if (jj_scan_token(TIME)) return true;
35925     if (jj_scan_token(ZONE)) return true;
35926     return false;
35927   }
35928 
35929   private boolean jj_3_35() {
35930     if (jj_scan_token(WITH)) return true;
35931     if (jj_scan_token(LOCAL)) return true;
35932     if (jj_scan_token(TIME)) return true;
35933     if (jj_scan_token(ZONE)) return true;
35934     return false;
35935   }
35936 
35937   private boolean jj_3R_207() {
35938     Token xsp;
35939     xsp = jj_scanpos;
35940     if (jj_3R_291()) {
35941     jj_scanpos = xsp;
35942     if (jj_3_35()) {
35943     jj_scanpos = xsp;
35944     if (jj_3_36()) {
35945     jj_scanpos = xsp;
35946     if (jj_3_37()) {
35947     jj_scanpos = xsp;
35948     if (jj_3_38()) return true;
35949     }
35950     }
35951     }
35952     }
35953     return false;
35954   }
35955 
35956   private boolean jj_3R_291() {
35957     if (jj_scan_token(CHARACTER)) return true;
35958     if (jj_scan_token(SET)) return true;
35959     if (jj_3R_295()) return true;
35960     return false;
35961   }
35962 
35963   private boolean jj_3_59() {
35964     if (jj_3R_143()) return true;
35965     Token xsp;
35966     xsp = jj_scanpos;
35967     if (jj_scan_token(23)) {
35968     jj_scanpos = xsp;
35969     if (jj_scan_token(51)) return true;
35970     }
35971     return false;
35972   }
35973 
35974   private boolean jj_3R_436() {
35975     Token xsp;
35976     xsp = jj_scanpos;
35977     if (jj_3_59()) jj_scanpos = xsp;
35978     if (jj_3R_234()) return true;
35979     xsp = jj_scanpos;
35980     if (jj_3R_569()) jj_scanpos = xsp;
35981     return false;
35982   }
35983 
35984   private boolean jj_3R_441() {
35985     if (jj_scan_token(BYTE)) return true;
35986     return false;
35987   }
35988 
35989   private boolean jj_3R_440() {
35990     if (jj_scan_token(CHAR)) return true;
35991     return false;
35992   }
35993 
35994   private boolean jj_3R_439() {
35995     if (jj_scan_token(6)) return true;
35996     if (jj_3R_484()) return true;
35997     return false;
35998   }
35999 
36000   private boolean jj_3R_536() {
36001     if (jj_scan_token(6)) return true;
36002     if (jj_3R_436()) return true;
36003     return false;
36004   }
36005 
36006   private boolean jj_3R_394() {
36007     if (jj_3R_436()) return true;
36008     Token xsp;
36009     while (true) {
36010       xsp = jj_scanpos;
36011       if (jj_3R_536()) { jj_scanpos = xsp; break; }
36012     }
36013     return false;
36014   }
36015 
36016   private boolean jj_3_33() {
36017     if (jj_scan_token(5)) return true;
36018     if (jj_3R_127()) return true;
36019     Token xsp;
36020     xsp = jj_scanpos;
36021     if (jj_3R_439()) jj_scanpos = xsp;
36022     xsp = jj_scanpos;
36023     if (jj_3R_440()) jj_scanpos = xsp;
36024     xsp = jj_scanpos;
36025     if (jj_3R_441()) jj_scanpos = xsp;
36026     if (jj_scan_token(7)) return true;
36027     return false;
36028   }
36029 
36030   private boolean jj_3R_342() {
36031     if (jj_3R_394()) return true;
36032     return false;
36033   }
36034 
36035   private boolean jj_3R_142() {
36036     if (jj_scan_token(11)) return true;
36037     return false;
36038   }
36039 
36040   private boolean jj_3R_283() {
36041     Token xsp;
36042     xsp = jj_scanpos;
36043     if (jj_scan_token(117)) {
36044     jj_scanpos = xsp;
36045     if (jj_scan_token(283)) {
36046     jj_scanpos = xsp;
36047     if (jj_scan_token(296)) {
36048     jj_scanpos = xsp;
36049     if (jj_scan_token(377)) {
36050     jj_scanpos = xsp;
36051     if (jj_scan_token(44)) {
36052     jj_scanpos = xsp;
36053     if (jj_scan_token(321)) {
36054     jj_scanpos = xsp;
36055     if (jj_scan_token(45)) {
36056     jj_scanpos = xsp;
36057     if (jj_scan_token(344)) {
36058     jj_scanpos = xsp;
36059     if (jj_scan_token(345)) {
36060     jj_scanpos = xsp;
36061     if (jj_scan_token(53)) {
36062     jj_scanpos = xsp;
36063     if (jj_scan_token(389)) {
36064     jj_scanpos = xsp;
36065     if (jj_scan_token(54)) {
36066     jj_scanpos = xsp;
36067     if (jj_scan_token(346)) {
36068     jj_scanpos = xsp;
36069     if (jj_scan_token(408)) {
36070     jj_scanpos = xsp;
36071     if (jj_scan_token(55)) {
36072     jj_scanpos = xsp;
36073     if (jj_scan_token(322)) {
36074     jj_scanpos = xsp;
36075     if (jj_scan_token(312)) {
36076     jj_scanpos = xsp;
36077     if (jj_scan_token(313)) {
36078     jj_scanpos = xsp;
36079     if (jj_scan_token(395)) {
36080     jj_scanpos = xsp;
36081     if (jj_scan_token(62)) {
36082     jj_scanpos = xsp;
36083     if (jj_scan_token(64)) {
36084     jj_scanpos = xsp;
36085     if (jj_scan_token(349)) {
36086     jj_scanpos = xsp;
36087     if (jj_scan_token(65)) {
36088     jj_scanpos = xsp;
36089     if (jj_scan_token(390)) {
36090     jj_scanpos = xsp;
36091     if (jj_scan_token(401)) {
36092     jj_scanpos = xsp;
36093     if (jj_scan_token(320)) {
36094     jj_scanpos = xsp;
36095     if (jj_scan_token(376)) {
36096     jj_scanpos = xsp;
36097     if (jj_scan_token(375)) {
36098     jj_scanpos = xsp;
36099     if (jj_scan_token(314)) {
36100     jj_scanpos = xsp;
36101     if (jj_scan_token(70)) {
36102     jj_scanpos = xsp;
36103     if (jj_scan_token(72)) {
36104     jj_scanpos = xsp;
36105     if (jj_scan_token(73)) {
36106     jj_scanpos = xsp;
36107     if (jj_scan_token(74)) {
36108     jj_scanpos = xsp;
36109     if (jj_scan_token(75)) {
36110     jj_scanpos = xsp;
36111     if (jj_scan_token(76)) {
36112     jj_scanpos = xsp;
36113     if (jj_scan_token(347)) {
36114     jj_scanpos = xsp;
36115     if (jj_scan_token(80)) {
36116     jj_scanpos = xsp;
36117     if (jj_scan_token(370)) {
36118     jj_scanpos = xsp;
36119     if (jj_scan_token(81)) {
36120     jj_scanpos = xsp;
36121     if (jj_scan_token(82)) {
36122     jj_scanpos = xsp;
36123     if (jj_scan_token(379)) {
36124     jj_scanpos = xsp;
36125     if (jj_scan_token(84)) {
36126     jj_scanpos = xsp;
36127     if (jj_scan_token(37)) {
36128     jj_scanpos = xsp;
36129     if (jj_scan_token(86)) {
36130     jj_scanpos = xsp;
36131     if (jj_scan_token(87)) {
36132     jj_scanpos = xsp;
36133     if (jj_scan_token(348)) {
36134     jj_scanpos = xsp;
36135     if (jj_scan_token(89)) {
36136     jj_scanpos = xsp;
36137     if (jj_scan_token(406)) {
36138     jj_scanpos = xsp;
36139     if (jj_scan_token(350)) {
36140     jj_scanpos = xsp;
36141     if (jj_scan_token(301)) {
36142     jj_scanpos = xsp;
36143     if (jj_scan_token(380)) {
36144     jj_scanpos = xsp;
36145     if (jj_scan_token(36)) {
36146     jj_scanpos = xsp;
36147     if (jj_scan_token(411)) {
36148     jj_scanpos = xsp;
36149     if (jj_scan_token(96)) {
36150     jj_scanpos = xsp;
36151     if (jj_scan_token(351)) {
36152     jj_scanpos = xsp;
36153     if (jj_scan_token(381)) {
36154     jj_scanpos = xsp;
36155     if (jj_scan_token(300)) {
36156     jj_scanpos = xsp;
36157     if (jj_scan_token(352)) {
36158     jj_scanpos = xsp;
36159     if (jj_scan_token(101)) {
36160     jj_scanpos = xsp;
36161     if (jj_scan_token(396)) {
36162     jj_scanpos = xsp;
36163     if (jj_scan_token(104)) {
36164     jj_scanpos = xsp;
36165     if (jj_scan_token(106)) {
36166     jj_scanpos = xsp;
36167     if (jj_scan_token(107)) {
36168     jj_scanpos = xsp;
36169     if (jj_scan_token(109)) {
36170     jj_scanpos = xsp;
36171     if (jj_scan_token(113)) {
36172     jj_scanpos = xsp;
36173     if (jj_scan_token(115)) {
36174     jj_scanpos = xsp;
36175     if (jj_scan_token(114)) {
36176     jj_scanpos = xsp;
36177     if (jj_scan_token(116)) {
36178     jj_scanpos = xsp;
36179     if (jj_scan_token(119)) {
36180     jj_scanpos = xsp;
36181     if (jj_scan_token(353)) {
36182     jj_scanpos = xsp;
36183     if (jj_scan_token(123)) {
36184     jj_scanpos = xsp;
36185     if (jj_scan_token(125)) {
36186     jj_scanpos = xsp;
36187     if (jj_scan_token(126)) {
36188     jj_scanpos = xsp;
36189     if (jj_scan_token(130)) {
36190     jj_scanpos = xsp;
36191     if (jj_scan_token(132)) {
36192     jj_scanpos = xsp;
36193     if (jj_scan_token(382)) {
36194     jj_scanpos = xsp;
36195     if (jj_scan_token(133)) {
36196     jj_scanpos = xsp;
36197     if (jj_scan_token(136)) {
36198     jj_scanpos = xsp;
36199     if (jj_scan_token(142)) {
36200     jj_scanpos = xsp;
36201     if (jj_scan_token(143)) {
36202     jj_scanpos = xsp;
36203     if (jj_scan_token(140)) {
36204     jj_scanpos = xsp;
36205     if (jj_scan_token(145)) {
36206     jj_scanpos = xsp;
36207     if (jj_scan_token(149)) {
36208     jj_scanpos = xsp;
36209     if (jj_scan_token(151)) {
36210     jj_scanpos = xsp;
36211     if (jj_scan_token(153)) {
36212     jj_scanpos = xsp;
36213     if (jj_scan_token(154)) {
36214     jj_scanpos = xsp;
36215     if (jj_scan_token(42)) {
36216     jj_scanpos = xsp;
36217     if (jj_scan_token(399)) {
36218     jj_scanpos = xsp;
36219     if (jj_scan_token(393)) {
36220     jj_scanpos = xsp;
36221     if (jj_scan_token(372)) {
36222     jj_scanpos = xsp;
36223     if (jj_scan_token(155)) {
36224     jj_scanpos = xsp;
36225     if (jj_scan_token(367)) {
36226     jj_scanpos = xsp;
36227     if (jj_scan_token(157)) {
36228     jj_scanpos = xsp;
36229     if (jj_scan_token(409)) {
36230     jj_scanpos = xsp;
36231     if (jj_scan_token(317)) {
36232     jj_scanpos = xsp;
36233     if (jj_scan_token(354)) {
36234     jj_scanpos = xsp;
36235     if (jj_scan_token(355)) {
36236     jj_scanpos = xsp;
36237     if (jj_scan_token(162)) {
36238     jj_scanpos = xsp;
36239     if (jj_scan_token(163)) {
36240     jj_scanpos = xsp;
36241     if (jj_scan_token(374)) {
36242     jj_scanpos = xsp;
36243     if (jj_scan_token(164)) {
36244     jj_scanpos = xsp;
36245     if (jj_scan_token(165)) {
36246     jj_scanpos = xsp;
36247     if (jj_scan_token(166)) {
36248     jj_scanpos = xsp;
36249     if (jj_scan_token(168)) {
36250     jj_scanpos = xsp;
36251     if (jj_scan_token(169)) {
36252     jj_scanpos = xsp;
36253     if (jj_scan_token(170)) {
36254     jj_scanpos = xsp;
36255     if (jj_scan_token(173)) {
36256     jj_scanpos = xsp;
36257     if (jj_scan_token(397)) {
36258     jj_scanpos = xsp;
36259     if (jj_scan_token(368)) {
36260     jj_scanpos = xsp;
36261     if (jj_scan_token(174)) {
36262     jj_scanpos = xsp;
36263     if (jj_scan_token(306)) {
36264     jj_scanpos = xsp;
36265     if (jj_scan_token(402)) {
36266     jj_scanpos = xsp;
36267     if (jj_scan_token(315)) {
36268     jj_scanpos = xsp;
36269     if (jj_scan_token(356)) {
36270     jj_scanpos = xsp;
36271     if (jj_scan_token(176)) {
36272     jj_scanpos = xsp;
36273     if (jj_scan_token(179)) {
36274     jj_scanpos = xsp;
36275     if (jj_scan_token(357)) {
36276     jj_scanpos = xsp;
36277     if (jj_scan_token(304)) {
36278     jj_scanpos = xsp;
36279     if (jj_scan_token(307)) {
36280     jj_scanpos = xsp;
36281     if (jj_scan_token(193)) {
36282     jj_scanpos = xsp;
36283     if (jj_scan_token(196)) {
36284     jj_scanpos = xsp;
36285     if (jj_scan_token(326)) {
36286     jj_scanpos = xsp;
36287     if (jj_scan_token(199)) {
36288     jj_scanpos = xsp;
36289     if (jj_scan_token(200)) {
36290     jj_scanpos = xsp;
36291     if (jj_scan_token(205)) {
36292     jj_scanpos = xsp;
36293     if (jj_scan_token(206)) {
36294     jj_scanpos = xsp;
36295     if (jj_scan_token(208)) {
36296     jj_scanpos = xsp;
36297     if (jj_scan_token(209)) {
36298     jj_scanpos = xsp;
36299     if (jj_scan_token(371)) {
36300     jj_scanpos = xsp;
36301     if (jj_scan_token(327)) {
36302     jj_scanpos = xsp;
36303     if (jj_scan_token(211)) {
36304     jj_scanpos = xsp;
36305     if (jj_scan_token(302)) {
36306     jj_scanpos = xsp;
36307     if (jj_scan_token(219)) {
36308     jj_scanpos = xsp;
36309     if (jj_scan_token(383)) {
36310     jj_scanpos = xsp;
36311     if (jj_scan_token(223)) {
36312     jj_scanpos = xsp;
36313     if (jj_scan_token(384)) {
36314     jj_scanpos = xsp;
36315     if (jj_scan_token(226)) {
36316     jj_scanpos = xsp;
36317     if (jj_scan_token(228)) {
36318     jj_scanpos = xsp;
36319     if (jj_scan_token(229)) {
36320     jj_scanpos = xsp;
36321     if (jj_scan_token(230)) {
36322     jj_scanpos = xsp;
36323     if (jj_scan_token(232)) {
36324     jj_scanpos = xsp;
36325     if (jj_scan_token(385)) {
36326     jj_scanpos = xsp;
36327     if (jj_scan_token(235)) {
36328     jj_scanpos = xsp;
36329     if (jj_scan_token(237)) {
36330     jj_scanpos = xsp;
36331     if (jj_scan_token(238)) {
36332     jj_scanpos = xsp;
36333     if (jj_scan_token(239)) {
36334     jj_scanpos = xsp;
36335     if (jj_scan_token(394)) {
36336     jj_scanpos = xsp;
36337     if (jj_scan_token(241)) {
36338     jj_scanpos = xsp;
36339     if (jj_scan_token(242)) {
36340     jj_scanpos = xsp;
36341     if (jj_scan_token(244)) {
36342     jj_scanpos = xsp;
36343     if (jj_scan_token(245)) {
36344     jj_scanpos = xsp;
36345     if (jj_scan_token(243)) {
36346     jj_scanpos = xsp;
36347     if (jj_scan_token(247)) {
36348     jj_scanpos = xsp;
36349     if (jj_scan_token(248)) {
36350     jj_scanpos = xsp;
36351     if (jj_scan_token(358)) {
36352     jj_scanpos = xsp;
36353     if (jj_scan_token(249)) {
36354     jj_scanpos = xsp;
36355     if (jj_scan_token(251)) {
36356     jj_scanpos = xsp;
36357     if (jj_scan_token(359)) {
36358     jj_scanpos = xsp;
36359     if (jj_scan_token(407)) {
36360     jj_scanpos = xsp;
36361     if (jj_scan_token(253)) {
36362     jj_scanpos = xsp;
36363     if (jj_scan_token(410)) {
36364     jj_scanpos = xsp;
36365     if (jj_scan_token(360)) {
36366     jj_scanpos = xsp;
36367     if (jj_scan_token(257)) {
36368     jj_scanpos = xsp;
36369     if (jj_scan_token(361)) {
36370     jj_scanpos = xsp;
36371     if (jj_scan_token(362)) {
36372     jj_scanpos = xsp;
36373     if (jj_scan_token(262)) {
36374     jj_scanpos = xsp;
36375     if (jj_scan_token(363)) {
36376     jj_scanpos = xsp;
36377     if (jj_scan_token(369)) {
36378     jj_scanpos = xsp;
36379     if (jj_scan_token(398)) {
36380     jj_scanpos = xsp;
36381     if (jj_scan_token(265)) {
36382     jj_scanpos = xsp;
36383     if (jj_scan_token(264)) {
36384     jj_scanpos = xsp;
36385     if (jj_scan_token(266)) {
36386     jj_scanpos = xsp;
36387     if (jj_scan_token(364)) {
36388     jj_scanpos = xsp;
36389     if (jj_scan_token(373)) {
36390     jj_scanpos = xsp;
36391     if (jj_scan_token(272)) {
36392     jj_scanpos = xsp;
36393     if (jj_scan_token(274)) {
36394     jj_scanpos = xsp;
36395     if (jj_scan_token(275)) {
36396     jj_scanpos = xsp;
36397     if (jj_scan_token(277)) {
36398     jj_scanpos = xsp;
36399     if (jj_scan_token(279)) {
36400     jj_scanpos = xsp;
36401     if (jj_scan_token(278)) {
36402     jj_scanpos = xsp;
36403     if (jj_scan_token(276)) {
36404     jj_scanpos = xsp;
36405     if (jj_scan_token(400)) {
36406     jj_scanpos = xsp;
36407     if (jj_scan_token(281)) {
36408     jj_scanpos = xsp;
36409     if (jj_scan_token(391)) {
36410     jj_scanpos = xsp;
36411     if (jj_scan_token(392)) {
36412     jj_scanpos = xsp;
36413     if (jj_scan_token(365)) {
36414     jj_scanpos = xsp;
36415     if (jj_scan_token(386)) {
36416     jj_scanpos = xsp;
36417     if (jj_scan_token(286)) {
36418     jj_scanpos = xsp;
36419     if (jj_scan_token(309)) {
36420     jj_scanpos = xsp;
36421     if (jj_scan_token(412)) {
36422     jj_scanpos = xsp;
36423     if (jj_scan_token(288)) {
36424     jj_scanpos = xsp;
36425     if (jj_scan_token(310)) {
36426     jj_scanpos = xsp;
36427     if (jj_scan_token(387)) {
36428     jj_scanpos = xsp;
36429     if (jj_scan_token(311)) {
36430     jj_scanpos = xsp;
36431     if (jj_scan_token(388)) {
36432     jj_scanpos = xsp;
36433     if (jj_scan_token(316)) {
36434     jj_scanpos = xsp;
36435     if (jj_scan_token(293)) {
36436     jj_scanpos = xsp;
36437     if (jj_scan_token(319)) {
36438     jj_scanpos = xsp;
36439     if (jj_scan_token(294)) {
36440     jj_scanpos = xsp;
36441     if (jj_scan_token(366)) {
36442     jj_scanpos = xsp;
36443     if (jj_scan_token(270)) {
36444     jj_scanpos = xsp;
36445     if (jj_scan_token(100)) {
36446     jj_scanpos = xsp;
36447     if (jj_scan_token(182)) {
36448     jj_scanpos = xsp;
36449     if (jj_scan_token(378)) {
36450     jj_scanpos = xsp;
36451     if (jj_scan_token(186)) {
36452     jj_scanpos = xsp;
36453     if (jj_scan_token(233)) {
36454     jj_scanpos = xsp;
36455     if (jj_scan_token(231)) {
36456     jj_scanpos = xsp;
36457     if (jj_scan_token(43)) return true;
36458     }
36459     }
36460     }
36461     }
36462     }
36463     }
36464     }
36465     }
36466     }
36467     }
36468     }
36469     }
36470     }
36471     }
36472     }
36473     }
36474     }
36475     }
36476     }
36477     }
36478     }
36479     }
36480     }
36481     }
36482     }
36483     }
36484     }
36485     }
36486     }
36487     }
36488     }
36489     }
36490     }
36491     }
36492     }
36493     }
36494     }
36495     }
36496     }
36497     }
36498     }
36499     }
36500     }
36501     }
36502     }
36503     }
36504     }
36505     }
36506     }
36507     }
36508     }
36509     }
36510     }
36511     }
36512     }
36513     }
36514     }
36515     }
36516     }
36517     }
36518     }
36519     }
36520     }
36521     }
36522     }
36523     }
36524     }
36525     }
36526     }
36527     }
36528     }
36529     }
36530     }
36531     }
36532     }
36533     }
36534     }
36535     }
36536     }
36537     }
36538     }
36539     }
36540     }
36541     }
36542     }
36543     }
36544     }
36545     }
36546     }
36547     }
36548     }
36549     }
36550     }
36551     }
36552     }
36553     }
36554     }
36555     }
36556     }
36557     }
36558     }
36559     }
36560     }
36561     }
36562     }
36563     }
36564     }
36565     }
36566     }
36567     }
36568     }
36569     }
36570     }
36571     }
36572     }
36573     }
36574     }
36575     }
36576     }
36577     }
36578     }
36579     }
36580     }
36581     }
36582     }
36583     }
36584     }
36585     }
36586     }
36587     }
36588     }
36589     }
36590     }
36591     }
36592     }
36593     }
36594     }
36595     }
36596     }
36597     }
36598     }
36599     }
36600     }
36601     }
36602     }
36603     }
36604     }
36605     }
36606     }
36607     }
36608     }
36609     }
36610     }
36611     }
36612     }
36613     }
36614     }
36615     }
36616     }
36617     }
36618     }
36619     }
36620     }
36621     }
36622     }
36623     }
36624     }
36625     }
36626     }
36627     }
36628     }
36629     }
36630     }
36631     }
36632     }
36633     }
36634     }
36635     }
36636     }
36637     }
36638     }
36639     }
36640     }
36641     }
36642     }
36643     }
36644     }
36645     }
36646     }
36647     }
36648     }
36649     }
36650     }
36651     }
36652     }
36653     }
36654     }
36655     }
36656     }
36657     }
36658     }
36659     }
36660     }
36661     }
36662     }
36663     }
36664     }
36665     return false;
36666   }
36667 
36668   private boolean jj_3R_206() {
36669     if (jj_scan_token(SELF)) return true;
36670     if (jj_scan_token(AS)) return true;
36671     if (jj_scan_token(RESULT)) return true;
36672     return false;
36673   }
36674 
36675   private boolean jj_3R_203() {
36676     if (jj_scan_token(DOUBLE)) return true;
36677     if (jj_scan_token(PRECISION)) return true;
36678     return false;
36679   }
36680 
36681   private boolean jj_3R_299() {
36682     if (jj_scan_token(5)) return true;
36683     Token xsp;
36684     xsp = jj_scanpos;
36685     if (jj_3R_342()) jj_scanpos = xsp;
36686     if (jj_scan_token(7)) return true;
36687     return false;
36688   }
36689 
36690   private boolean jj_3_32() {
36691     if (jj_scan_token(INTERVAL)) return true;
36692     if (jj_scan_token(DAY)) return true;
36693     return false;
36694   }
36695 
36696   private boolean jj_3_31() {
36697     if (jj_scan_token(INTERVAL)) return true;
36698     if (jj_scan_token(YEAR)) return true;
36699     return false;
36700   }
36701 
36702   private boolean jj_3R_353() {
36703     if (jj_scan_token(3)) return true;
36704     if (jj_3R_120()) return true;
36705     return false;
36706   }
36707 
36708   private boolean jj_3R_205() {
36709     if (jj_scan_token(REF)) return true;
36710     if (jj_scan_token(CURSOR)) return true;
36711     return false;
36712   }
36713 
36714   private boolean jj_3R_128() {
36715     if (jj_3R_143()) return true;
36716     Token xsp;
36717     while (true) {
36718       xsp = jj_scanpos;
36719       if (jj_3R_353()) { jj_scanpos = xsp; break; }
36720     }
36721     return false;
36722   }
36723 
36724   private boolean jj_3_30() {
36725     if (jj_scan_token(LONG)) return true;
36726     if (jj_scan_token(RAW)) return true;
36727     return false;
36728   }
36729 
36730   private boolean jj_3R_141() {
36731     if (jj_scan_token(3)) return true;
36732     return false;
36733   }
36734 
36735   private boolean jj_3_58() {
36736     Token xsp;
36737     xsp = jj_scanpos;
36738     if (jj_3R_141()) {
36739     jj_scanpos = xsp;
36740     if (jj_3R_142()) return true;
36741     }
36742     if (jj_3R_120()) return true;
36743     return false;
36744   }
36745 
36746   private boolean jj_3R_204() {
36747     Token xsp;
36748     xsp = jj_scanpos;
36749     if (jj_scan_token(67)) {
36750     jj_scanpos = xsp;
36751     if (jj_scan_token(320)) {
36752     jj_scanpos = xsp;
36753     if (jj_3_30()) {
36754     jj_scanpos = xsp;
36755     if (jj_scan_token(160)) {
36756     jj_scanpos = xsp;
36757     if (jj_scan_token(306)) {
36758     jj_scanpos = xsp;
36759     if (jj_scan_token(307)) {
36760     jj_scanpos = xsp;
36761     if (jj_scan_token(227)) {
36762     jj_scanpos = xsp;
36763     if (jj_scan_token(244)) {
36764     jj_scanpos = xsp;
36765     if (jj_scan_token(308)) {
36766     jj_scanpos = xsp;
36767     if (jj_scan_token(309)) {
36768     jj_scanpos = xsp;
36769     if (jj_scan_token(298)) {
36770     jj_scanpos = xsp;
36771     if (jj_scan_token(299)) {
36772     jj_scanpos = xsp;
36773     if (jj_scan_token(314)) {
36774     jj_scanpos = xsp;
36775     if (jj_scan_token(315)) return true;
36776     }
36777     }
36778     }
36779     }
36780     }
36781     }
36782     }
36783     }
36784     }
36785     }
36786     }
36787     }
36788     }
36789     return false;
36790   }
36791 
36792   private boolean jj_3R_295() {
36793     if (jj_3R_143()) return true;
36794     Token xsp;
36795     while (true) {
36796       xsp = jj_scanpos;
36797       if (jj_3_58()) { jj_scanpos = xsp; break; }
36798     }
36799     return false;
36800   }
36801 
36802   private boolean jj_3R_191() {
36803     if (jj_scan_token(21)) return true;
36804     if (jj_3R_143()) return true;
36805     if (jj_scan_token(22)) return true;
36806     return false;
36807   }
36808 
36809   private boolean jj_3R_126() {
36810     Token xsp;
36811     xsp = jj_scanpos;
36812     if (jj_scan_token(188)) {
36813     jj_scanpos = xsp;
36814     if (jj_scan_token(189)) {
36815     jj_scanpos = xsp;
36816     if (jj_scan_token(68)) {
36817     jj_scanpos = xsp;
36818     if (jj_scan_token(190)) {
36819     jj_scanpos = xsp;
36820     if (jj_scan_token(191)) {
36821     jj_scanpos = xsp;
36822     if (jj_scan_token(192)) {
36823     jj_scanpos = xsp;
36824     if (jj_scan_token(59)) {
36825     jj_scanpos = xsp;
36826     if (jj_scan_token(301)) {
36827     jj_scanpos = xsp;
36828     if (jj_scan_token(91)) {
36829     jj_scanpos = xsp;
36830     if (jj_3R_203()) {
36831     jj_scanpos = xsp;
36832     if (jj_scan_token(120)) {
36833     jj_scanpos = xsp;
36834     if (jj_scan_token(303)) {
36835     jj_scanpos = xsp;
36836     if (jj_scan_token(146)) {
36837     jj_scanpos = xsp;
36838     if (jj_scan_token(174)) {
36839     jj_scanpos = xsp;
36840     if (jj_scan_token(175)) {
36841     jj_scanpos = xsp;
36842     if (jj_scan_token(187)) {
36843     jj_scanpos = xsp;
36844     if (jj_scan_token(304)) {
36845     jj_scanpos = xsp;
36846     if (jj_scan_token(215)) {
36847     jj_scanpos = xsp;
36848     if (jj_scan_token(216)) {
36849     jj_scanpos = xsp;
36850     if (jj_scan_token(217)) {
36851     jj_scanpos = xsp;
36852     if (jj_scan_token(228)) {
36853     jj_scanpos = xsp;
36854     if (jj_scan_token(305)) {
36855     jj_scanpos = xsp;
36856     if (jj_scan_token(256)) {
36857     jj_scanpos = xsp;
36858     if (jj_3R_204()) {
36859     jj_scanpos = xsp;
36860     if (jj_scan_token(61)) {
36861     jj_scanpos = xsp;
36862     if (jj_scan_token(312)) {
36863     jj_scanpos = xsp;
36864     if (jj_scan_token(313)) {
36865     jj_scanpos = xsp;
36866     if (jj_scan_token(270)) {
36867     jj_scanpos = xsp;
36868     if (jj_3R_205()) {
36869     jj_scanpos = xsp;
36870     if (jj_scan_token(88)) {
36871     jj_scanpos = xsp;
36872     if (jj_3_31()) {
36873     jj_scanpos = xsp;
36874     if (jj_3_32()) {
36875     jj_scanpos = xsp;
36876     if (jj_scan_token(274)) {
36877     jj_scanpos = xsp;
36878     if (jj_scan_token(275)) {
36879     jj_scanpos = xsp;
36880     if (jj_3R_206()) return true;
36881     }
36882     }
36883     }
36884     }
36885     }
36886     }
36887     }
36888     }
36889     }
36890     }
36891     }
36892     }
36893     }
36894     }
36895     }
36896     }
36897     }
36898     }
36899     }
36900     }
36901     }
36902     }
36903     }
36904     }
36905     }
36906     }
36907     }
36908     }
36909     }
36910     }
36911     }
36912     }
36913     }
36914     }
36915     xsp = jj_scanpos;
36916     if (jj_3_33()) jj_scanpos = xsp;
36917     xsp = jj_scanpos;
36918     if (jj_3R_207()) jj_scanpos = xsp;
36919     return false;
36920   }
36921 
36922   private boolean jj_3R_240() {
36923     if (jj_scan_token(VARYING)) return true;
36924     if (jj_scan_token(ARRAY)) return true;
36925     return false;
36926   }
36927 
36928   private boolean jj_3R_127() {
36929     if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36930     return false;
36931   }
36932 
36933   private boolean jj_3_29() {
36934     if (jj_scan_token(5)) return true;
36935     if (jj_3R_127()) return true;
36936     return false;
36937   }
36938 
36939   private boolean jj_3R_146() {
36940     Token xsp;
36941     xsp = jj_scanpos;
36942     if (jj_scan_token(271)) {
36943     jj_scanpos = xsp;
36944     if (jj_scan_token(310)) {
36945     jj_scanpos = xsp;
36946     if (jj_3R_240()) return true;
36947     }
36948     }
36949     xsp = jj_scanpos;
36950     if (jj_3_29()) jj_scanpos = xsp;
36951     return false;
36952   }
36953 
36954   private boolean jj_3R_400() {
36955     if (jj_scan_token(CC_ELSE)) return true;
36956     if (jj_3R_236()) return true;
36957     return false;
36958   }
36959 
36960   private boolean jj_3R_227() {
36961     if (jj_scan_token(A)) return true;
36962     if (jj_scan_token(SET)) return true;
36963     return false;
36964   }
36965 
36966   private boolean jj_3R_137() {
36967     Token xsp;
36968     xsp = jj_scanpos;
36969     if (jj_3R_227()) {
36970     jj_scanpos = xsp;
36971     if (jj_scan_token(396)) return true;
36972     }
36973     return false;
36974   }
36975 
36976   private boolean jj_3R_399() {
36977     if (jj_scan_token(CC_ELSIF)) return true;
36978     if (jj_3R_344()) return true;
36979     if (jj_scan_token(CC_THEN)) return true;
36980     if (jj_3R_236()) return true;
36981     return false;
36982   }
36983 
36984   private boolean jj_3R_392() {
36985     if (jj_scan_token(NULL)) return true;
36986     return false;
36987   }
36988 
36989   private boolean jj_3R_346() {
36990     if (jj_scan_token(CC_IF)) return true;
36991     if (jj_3R_344()) return true;
36992     if (jj_scan_token(CC_THEN)) return true;
36993     if (jj_3R_236()) return true;
36994     Token xsp;
36995     while (true) {
36996       xsp = jj_scanpos;
36997       if (jj_3R_399()) { jj_scanpos = xsp; break; }
36998     }
36999     while (true) {
37000       xsp = jj_scanpos;
37001       if (jj_3R_400()) { jj_scanpos = xsp; break; }
37002     }
37003     if (jj_scan_token(CC_END)) return true;
37004     return false;
37005   }
37006 
37007   private boolean jj_3R_348() {
37008     if (jj_scan_token(11)) return true;
37009     Token xsp;
37010     xsp = jj_scanpos;
37011     if (jj_scan_token(284)) {
37012     jj_scanpos = xsp;
37013     if (jj_scan_token(246)) return true;
37014     }
37015     return false;
37016   }
37017 
37018   private boolean jj_3R_347() {
37019     if (jj_scan_token(2)) return true;
37020     if (jj_3R_128()) return true;
37021     return false;
37022   }
37023 
37024   private boolean jj_3_27() {
37025     if (jj_scan_token(REF)) return true;
37026     return false;
37027   }
37028 
37029   private boolean jj_3R_305() {
37030     Token xsp;
37031     xsp = jj_scanpos;
37032     if (jj_3_27()) jj_scanpos = xsp;
37033     if (jj_3R_128()) return true;
37034     xsp = jj_scanpos;
37035     if (jj_3R_347()) jj_scanpos = xsp;
37036     xsp = jj_scanpos;
37037     if (jj_3R_348()) jj_scanpos = xsp;
37038     return false;
37039   }
37040 
37041   private boolean jj_3_28() {
37042     if (jj_3R_126()) return true;
37043     return false;
37044   }
37045 
37046   private boolean jj_3R_391() {
37047     Token xsp;
37048     xsp = jj_scanpos;
37049     if (jj_scan_token(283)) {
37050     jj_scanpos = xsp;
37051     if (jj_scan_token(117)) return true;
37052     }
37053     return false;
37054   }
37055 
37056   private boolean jj_3R_304() {
37057     if (jj_3R_346()) return true;
37058     return false;
37059   }
37060 
37061   private boolean jj_3R_236() {
37062     Token xsp;
37063     xsp = jj_scanpos;
37064     if (jj_3R_304()) {
37065     jj_scanpos = xsp;
37066     if (jj_3_28()) {
37067     jj_scanpos = xsp;
37068     if (jj_3R_305()) return true;
37069     }
37070     }
37071     return false;
37072   }
37073 
37074   private boolean jj_3R_335() {
37075     if (jj_scan_token(_DEFAULT)) return true;
37076     return false;
37077   }
37078 
37079   private boolean jj_3R_336() {
37080     if (jj_3R_234()) return true;
37081     return false;
37082   }
37083 
37084   private boolean jj_3R_284() {
37085     if (jj_3R_124()) return true;
37086     return false;
37087   }
37088 
37089   private boolean jj_3R_334() {
37090     if (jj_scan_token(9)) return true;
37091     if (jj_scan_token(10)) return true;
37092     return false;
37093   }
37094 
37095   private boolean jj_3R_183() {
37096     if (jj_scan_token(STRING_LITERAL)) return true;
37097     return false;
37098   }
37099 
37100   private boolean jj_3R_286() {
37101     Token xsp;
37102     xsp = jj_scanpos;
37103     if (jj_3R_334()) {
37104     jj_scanpos = xsp;
37105     if (jj_3R_335()) return true;
37106     }
37107     if (jj_3R_336()) return true;
37108     return false;
37109   }
37110 
37111   private boolean jj_3R_333() {
37112     if (jj_scan_token(NOT)) return true;
37113     return false;
37114   }
37115 
37116   private boolean jj_3R_285() {
37117     Token xsp;
37118     xsp = jj_scanpos;
37119     if (jj_3R_333()) jj_scanpos = xsp;
37120     if (jj_scan_token(NULL)) return true;
37121     return false;
37122   }
37123 
37124   private boolean jj_3_26() {
37125     if (jj_scan_token(CONSTANT)) return true;
37126     return false;
37127   }
37128 
37129   private boolean jj_3R_198() {
37130     if (jj_3R_284()) return true;
37131     Token xsp;
37132     xsp = jj_scanpos;
37133     if (jj_3_26()) jj_scanpos = xsp;
37134     if (jj_3R_236()) return true;
37135     xsp = jj_scanpos;
37136     if (jj_3R_285()) jj_scanpos = xsp;
37137     xsp = jj_scanpos;
37138     if (jj_3R_286()) jj_scanpos = xsp;
37139     return false;
37140   }
37141 
37142   private boolean jj_3R_515() {
37143     if (jj_scan_token(6)) return true;
37144     if (jj_3R_475()) return true;
37145     return false;
37146   }
37147 
37148   private boolean jj_3R_428() {
37149     if (jj_3R_475()) return true;
37150     Token xsp;
37151     while (true) {
37152       xsp = jj_scanpos;
37153       if (jj_3R_515()) { jj_scanpos = xsp; break; }
37154     }
37155     return false;
37156   }
37157 
37158   private boolean jj_3R_197() {
37159     if (jj_3R_283()) return true;
37160     return false;
37161   }
37162 
37163   private boolean jj_3R_341() {
37164     if (jj_3R_393()) return true;
37165     return false;
37166   }
37167 
37168   private boolean jj_3R_340() {
37169     if (jj_3R_392()) return true;
37170     return false;
37171   }
37172 
37173   private boolean jj_3R_386() {
37174     if (jj_scan_token(5)) return true;
37175     Token xsp;
37176     xsp = jj_scanpos;
37177     if (jj_3R_428()) jj_scanpos = xsp;
37178     if (jj_scan_token(7)) return true;
37179     return false;
37180   }
37181 
37182   private boolean jj_3R_339() {
37183     if (jj_3R_391()) return true;
37184     return false;
37185   }
37186 
37187   private boolean jj_3R_338() {
37188     if (jj_3R_183()) return true;
37189     return false;
37190   }
37191 
37192   private boolean jj_3R_120() {
37193     Token xsp;
37194     xsp = jj_scanpos;
37195     if (jj_scan_token(420)) {
37196     jj_scanpos = xsp;
37197     if (jj_scan_token(428)) {
37198     jj_scanpos = xsp;
37199     if (jj_3R_197()) {
37200     jj_scanpos = xsp;
37201     if (jj_scan_token(35)) {
37202     jj_scanpos = xsp;
37203     if (jj_scan_token(38)) {
37204     jj_scanpos = xsp;
37205     if (jj_scan_token(39)) {
37206     jj_scanpos = xsp;
37207     if (jj_scan_token(40)) {
37208     jj_scanpos = xsp;
37209     if (jj_scan_token(41)) {
37210     jj_scanpos = xsp;
37211     if (jj_scan_token(50)) {
37212     jj_scanpos = xsp;
37213     if (jj_scan_token(56)) {
37214     jj_scanpos = xsp;
37215     if (jj_scan_token(59)) {
37216     jj_scanpos = xsp;
37217     if (jj_scan_token(60)) {
37218     jj_scanpos = xsp;
37219     if (jj_scan_token(61)) {
37220     jj_scanpos = xsp;
37221     if (jj_scan_token(67)) {
37222     jj_scanpos = xsp;
37223     if (jj_scan_token(68)) {
37224     jj_scanpos = xsp;
37225     if (jj_scan_token(79)) {
37226     jj_scanpos = xsp;
37227     if (jj_scan_token(85)) {
37228     jj_scanpos = xsp;
37229     if (jj_scan_token(88)) {
37230     jj_scanpos = xsp;
37231     if (jj_scan_token(91)) {
37232     jj_scanpos = xsp;
37233     if (jj_scan_token(93)) {
37234     jj_scanpos = xsp;
37235     if (jj_scan_token(98)) {
37236     jj_scanpos = xsp;
37237     if (jj_scan_token(103)) {
37238     jj_scanpos = xsp;
37239     if (jj_scan_token(111)) {
37240     jj_scanpos = xsp;
37241     if (jj_scan_token(112)) {
37242     jj_scanpos = xsp;
37243     if (jj_scan_token(120)) {
37244     jj_scanpos = xsp;
37245     if (jj_scan_token(122)) {
37246     jj_scanpos = xsp;
37247     if (jj_scan_token(146)) {
37248     jj_scanpos = xsp;
37249     if (jj_scan_token(147)) {
37250     jj_scanpos = xsp;
37251     if (jj_scan_token(160)) {
37252     jj_scanpos = xsp;
37253     if (jj_scan_token(161)) {
37254     jj_scanpos = xsp;
37255     if (jj_scan_token(171)) {
37256     jj_scanpos = xsp;
37257     if (jj_scan_token(175)) {
37258     jj_scanpos = xsp;
37259     if (jj_scan_token(178)) {
37260     jj_scanpos = xsp;
37261     if (jj_scan_token(181)) {
37262     jj_scanpos = xsp;
37263     if (jj_scan_token(187)) {
37264     jj_scanpos = xsp;
37265     if (jj_scan_token(188)) {
37266     jj_scanpos = xsp;
37267     if (jj_scan_token(189)) {
37268     jj_scanpos = xsp;
37269     if (jj_scan_token(190)) {
37270     jj_scanpos = xsp;
37271     if (jj_scan_token(191)) {
37272     jj_scanpos = xsp;
37273     if (jj_scan_token(192)) {
37274     jj_scanpos = xsp;
37275     if (jj_scan_token(194)) {
37276     jj_scanpos = xsp;
37277     if (jj_scan_token(201)) {
37278     jj_scanpos = xsp;
37279     if (jj_scan_token(207)) {
37280     jj_scanpos = xsp;
37281     if (jj_scan_token(215)) {
37282     jj_scanpos = xsp;
37283     if (jj_scan_token(216)) {
37284     jj_scanpos = xsp;
37285     if (jj_scan_token(217)) {
37286     jj_scanpos = xsp;
37287     if (jj_scan_token(218)) {
37288     jj_scanpos = xsp;
37289     if (jj_scan_token(220)) {
37290     jj_scanpos = xsp;
37291     if (jj_scan_token(222)) {
37292     jj_scanpos = xsp;
37293     if (jj_scan_token(221)) {
37294     jj_scanpos = xsp;
37295     if (jj_scan_token(225)) {
37296     jj_scanpos = xsp;
37297     if (jj_scan_token(227)) {
37298     jj_scanpos = xsp;
37299     if (jj_scan_token(246)) {
37300     jj_scanpos = xsp;
37301     if (jj_scan_token(252)) {
37302     jj_scanpos = xsp;
37303     if (jj_scan_token(256)) {
37304     jj_scanpos = xsp;
37305     if (jj_scan_token(259)) {
37306     jj_scanpos = xsp;
37307     if (jj_scan_token(260)) {
37308     jj_scanpos = xsp;
37309     if (jj_scan_token(263)) {
37310     jj_scanpos = xsp;
37311     if (jj_scan_token(267)) {
37312     jj_scanpos = xsp;
37313     if (jj_scan_token(268)) {
37314     jj_scanpos = xsp;
37315     if (jj_scan_token(269)) {
37316     jj_scanpos = xsp;
37317     if (jj_scan_token(282)) {
37318     jj_scanpos = xsp;
37319     if (jj_scan_token(284)) {
37320     jj_scanpos = xsp;
37321     if (jj_scan_token(285)) {
37322     jj_scanpos = xsp;
37323     if (jj_scan_token(298)) {
37324     jj_scanpos = xsp;
37325     if (jj_scan_token(299)) {
37326     jj_scanpos = xsp;
37327     if (jj_scan_token(303)) {
37328     jj_scanpos = xsp;
37329     if (jj_scan_token(305)) {
37330     jj_scanpos = xsp;
37331     if (jj_scan_token(308)) {
37332     jj_scanpos = xsp;
37333     if (jj_scan_token(292)) return true;
37334     }
37335     }
37336     }
37337     }
37338     }
37339     }
37340     }
37341     }
37342     }
37343     }
37344     }
37345     }
37346     }
37347     }
37348     }
37349     }
37350     }
37351     }
37352     }
37353     }
37354     }
37355     }
37356     }
37357     }
37358     }
37359     }
37360     }
37361     }
37362     }
37363     }
37364     }
37365     }
37366     }
37367     }
37368     }
37369     }
37370     }
37371     }
37372     }
37373     }
37374     }
37375     }
37376     }
37377     }
37378     }
37379     }
37380     }
37381     }
37382     }
37383     }
37384     }
37385     }
37386     }
37387     }
37388     }
37389     }
37390     }
37391     }
37392     }
37393     }
37394     }
37395     }
37396     }
37397     }
37398     }
37399     }
37400     }
37401     }
37402     }
37403     return false;
37404   }
37405 
37406   private boolean jj_3_23() {
37407     if (jj_scan_token(NOCOPY)) return true;
37408     return false;
37409   }
37410 
37411   private boolean jj_3R_326() {
37412     if (jj_3R_386()) return true;
37413     return false;
37414   }
37415 
37416   private boolean jj_3R_337() {
37417     if (jj_3R_127()) return true;
37418     return false;
37419   }
37420 
37421   private boolean jj_3R_294() {
37422     Token xsp;
37423     xsp = jj_scanpos;
37424     if (jj_3R_337()) {
37425     jj_scanpos = xsp;
37426     if (jj_scan_token(425)) {
37427     jj_scanpos = xsp;
37428     if (jj_3R_338()) {
37429     jj_scanpos = xsp;
37430     if (jj_3R_339()) {
37431     jj_scanpos = xsp;
37432     if (jj_3R_340()) {
37433     jj_scanpos = xsp;
37434     if (jj_3R_341()) return true;
37435     }
37436     }
37437     }
37438     }
37439     }
37440     return false;
37441   }
37442 
37443   private boolean jj_3R_479() {
37444     if (jj_3R_234()) return true;
37445     return false;
37446   }
37447 
37448   private boolean jj_3R_478() {
37449     if (jj_3R_183()) return true;
37450     return false;
37451   }
37452 
37453   private boolean jj_3R_477() {
37454     if (jj_scan_token(SESSIONTIMEZONE)) return true;
37455     return false;
37456   }
37457 
37458   private boolean jj_3R_325() {
37459     if (jj_scan_token(RETURN)) return true;
37460     if (jj_3R_236()) return true;
37461     return false;
37462   }
37463 
37464   private boolean jj_3R_476() {
37465     if (jj_scan_token(DBTIMEZONE)) return true;
37466     return false;
37467   }
37468 
37469   private boolean jj_3R_279() {
37470     if (jj_scan_token(PROCEDURE)) return true;
37471     if (jj_3R_155()) return true;
37472     Token xsp;
37473     xsp = jj_scanpos;
37474     if (jj_3R_326()) jj_scanpos = xsp;
37475     return false;
37476   }
37477 
37478   private boolean jj_3R_464() {
37479     if (jj_3R_124()) return true;
37480     return false;
37481   }
37482 
37483   private boolean jj_3R_125() {
37484     if (jj_scan_token(IN)) return true;
37485     if (jj_scan_token(OUT)) return true;
37486     return false;
37487   }
37488 
37489   private boolean jj_3R_298() {
37490     if (jj_scan_token(TIME)) return true;
37491     if (jj_scan_token(ZONE)) return true;
37492     Token xsp;
37493     xsp = jj_scanpos;
37494     if (jj_3R_476()) {
37495     jj_scanpos = xsp;
37496     if (jj_3R_477()) {
37497     jj_scanpos = xsp;
37498     if (jj_3R_478()) {
37499     jj_scanpos = xsp;
37500     if (jj_3R_479()) return true;
37501     }
37502     }
37503     }
37504     return false;
37505   }
37506 
37507   private boolean jj_3R_226() {
37508     if (jj_3R_299()) return true;
37509     return false;
37510   }
37511 
37512   private boolean jj_3R_297() {
37513     if (jj_scan_token(LOCAL)) return true;
37514     return false;
37515   }
37516 
37517   private boolean jj_3R_238() {
37518     if (jj_3R_283()) return true;
37519     return false;
37520   }
37521 
37522   private boolean jj_3R_324() {
37523     if (jj_3R_386()) return true;
37524     return false;
37525   }
37526 
37527   private boolean jj_3R_225() {
37528     if (jj_scan_token(AT)) return true;
37529     Token xsp;
37530     xsp = jj_scanpos;
37531     if (jj_3R_297()) {
37532     jj_scanpos = xsp;
37533     if (jj_3R_298()) return true;
37534     }
37535     return false;
37536   }
37537 
37538   private boolean jj_3R_224() {
37539     if (jj_scan_token(2)) return true;
37540     if (jj_3R_120()) return true;
37541     return false;
37542   }
37543 
37544   private boolean jj_3R_278() {
37545     if (jj_scan_token(FUNCTION)) return true;
37546     if (jj_3R_155()) return true;
37547     Token xsp;
37548     xsp = jj_scanpos;
37549     if (jj_3R_324()) jj_scanpos = xsp;
37550     xsp = jj_scanpos;
37551     if (jj_3R_325()) jj_scanpos = xsp;
37552     return false;
37553   }
37554 
37555   private boolean jj_3R_143() {
37556     Token xsp;
37557     xsp = jj_scanpos;
37558     if (jj_scan_token(420)) {
37559     jj_scanpos = xsp;
37560     if (jj_scan_token(428)) {
37561     jj_scanpos = xsp;
37562     if (jj_3R_238()) {
37563     jj_scanpos = xsp;
37564     if (jj_scan_token(60)) {
37565     jj_scanpos = xsp;
37566     if (jj_scan_token(171)) {
37567     jj_scanpos = xsp;
37568     if (jj_scan_token(201)) {
37569     jj_scanpos = xsp;
37570     if (jj_scan_token(222)) {
37571     jj_scanpos = xsp;
37572     if (jj_scan_token(227)) {
37573     jj_scanpos = xsp;
37574     if (jj_scan_token(35)) {
37575     jj_scanpos = xsp;
37576     if (jj_scan_token(308)) {
37577     jj_scanpos = xsp;
37578     if (jj_scan_token(258)) {
37579     jj_scanpos = xsp;
37580     if (jj_scan_token(259)) {
37581     jj_scanpos = xsp;
37582     if (jj_scan_token(260)) {
37583     jj_scanpos = xsp;
37584     if (jj_scan_token(269)) {
37585     jj_scanpos = xsp;
37586     if (jj_scan_token(284)) {
37587     jj_scanpos = xsp;
37588     if (jj_scan_token(161)) {
37589     jj_scanpos = xsp;
37590     if (jj_scan_token(303)) {
37591     jj_scanpos = xsp;
37592     if (jj_scan_token(50)) return true;
37593     }
37594     }
37595     }
37596     }
37597     }
37598     }
37599     }
37600     }
37601     }
37602     }
37603     }
37604     }
37605     }
37606     }
37607     }
37608     }
37609     }
37610     return false;
37611   }
37612 
37613   private boolean jj_3R_625() {
37614     if (jj_scan_token(3)) return true;
37615     if (jj_3R_124()) return true;
37616     return false;
37617   }
37618 
37619   private boolean jj_3R_194() {
37620     Token xsp;
37621     xsp = jj_scanpos;
37622     if (jj_3R_278()) {
37623     jj_scanpos = xsp;
37624     if (jj_3R_279()) return true;
37625     }
37626     return false;
37627   }
37628 
37629   private boolean jj_3R_636() {
37630     if (jj_scan_token(NOT)) return true;
37631     return false;
37632   }
37633 
37634   private boolean jj_3R_624() {
37635     if (jj_scan_token(6)) return true;
37636     if (jj_3R_124()) return true;
37637     return false;
37638   }
37639 
37640   private boolean jj_3R_223() {
37641     if (jj_scan_token(3)) return true;
37642     if (jj_3R_120()) return true;
37643     return false;
37644   }
37645 
37646   private boolean jj_3_24() {
37647     Token xsp;
37648     xsp = jj_scanpos;
37649     if (jj_scan_token(207)) {
37650     jj_scanpos = xsp;
37651     if (jj_3R_125()) return true;
37652     }
37653     xsp = jj_scanpos;
37654     if (jj_3_23()) jj_scanpos = xsp;
37655     return false;
37656   }
37657 
37658   private boolean jj_3R_136() {
37659     Token xsp;
37660     xsp = jj_scanpos;
37661     if (jj_3R_223()) {
37662     jj_scanpos = xsp;
37663     if (jj_3R_224()) {
37664     jj_scanpos = xsp;
37665     if (jj_3R_225()) {
37666     jj_scanpos = xsp;
37667     if (jj_3R_226()) return true;
37668     }
37669     }
37670     }
37671     return false;
37672   }
37673 
37674   private boolean jj_3R_560() {
37675     if (jj_3R_236()) return true;
37676     return false;
37677   }
37678 
37679   private boolean jj_3R_463() {
37680     if (jj_3R_351()) return true;
37681     return false;
37682   }
37683 
37684   private boolean jj_3R_601() {
37685     if (jj_scan_token(6)) return true;
37686     if (jj_3R_124()) return true;
37687     Token xsp;
37688     xsp = jj_scanpos;
37689     if (jj_3R_625()) jj_scanpos = xsp;
37690     return false;
37691   }
37692 
37693   private boolean jj_3R_487() {
37694     if (jj_scan_token(3)) return true;
37695     if (jj_3R_124()) return true;
37696     return false;
37697   }
37698 
37699   private boolean jj_3R_471() {
37700     if (jj_3R_147()) return true;
37701     return false;
37702   }
37703 
37704   private boolean jj_3R_631() {
37705     if (jj_scan_token(NOT)) return true;
37706     return false;
37707   }
37708 
37709   private boolean jj_3R_470() {
37710     if (jj_3R_118()) return true;
37711     return false;
37712   }
37713 
37714   private boolean jj_3_57() {
37715     Token xsp;
37716     if (jj_scan_token(5)) return true;
37717     while (true) {
37718       xsp = jj_scanpos;
37719       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37720     }
37721     if (jj_scan_token(WITH)) return true;
37722     return false;
37723   }
37724 
37725   private boolean jj_3_56() {
37726     if (jj_scan_token(WITH)) return true;
37727     return false;
37728   }
37729 
37730   private boolean jj_3R_426() {
37731     Token xsp;
37732     xsp = jj_scanpos;
37733     if (jj_3R_470()) {
37734     jj_scanpos = xsp;
37735     if (jj_3R_471()) return true;
37736     }
37737     return false;
37738   }
37739 
37740   private boolean jj_3_55() {
37741     Token xsp;
37742     if (jj_scan_token(5)) return true;
37743     while (true) {
37744       xsp = jj_scanpos;
37745       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37746     }
37747     if (jj_scan_token(SELECT)) return true;
37748     return false;
37749   }
37750 
37751   private boolean jj_3R_598() {
37752     if (jj_scan_token(9)) return true;
37753     if (jj_scan_token(10)) return true;
37754     return false;
37755   }
37756 
37757   private boolean jj_3_54() {
37758     if (jj_scan_token(SELECT)) return true;
37759     return false;
37760   }
37761 
37762   private boolean jj_3R_296() {
37763     if (jj_scan_token(6)) return true;
37764     if (jj_3R_234()) return true;
37765     return false;
37766   }
37767 
37768   private boolean jj_3R_561() {
37769     Token xsp;
37770     xsp = jj_scanpos;
37771     if (jj_3R_598()) {
37772     jj_scanpos = xsp;
37773     if (jj_scan_token(92)) return true;
37774     }
37775     if (jj_3R_234()) return true;
37776     return false;
37777   }
37778 
37779   private boolean jj_3_25() {
37780     Token xsp;
37781     xsp = jj_scanpos;
37782     if (jj_3_24()) {
37783     jj_scanpos = xsp;
37784     if (jj_scan_token(137)) return true;
37785     }
37786     return false;
37787   }
37788 
37789   private boolean jj_3_53() {
37790     if (jj_3R_140()) return true;
37791     return false;
37792   }
37793 
37794   private boolean jj_3_52() {
37795     if (jj_3R_139()) return true;
37796     return false;
37797   }
37798 
37799   private boolean jj_3R_222() {
37800     if (jj_scan_token(5)) return true;
37801     if (jj_3R_234()) return true;
37802     Token xsp;
37803     while (true) {
37804       xsp = jj_scanpos;
37805       if (jj_3R_296()) { jj_scanpos = xsp; break; }
37806     }
37807     if (jj_scan_token(7)) return true;
37808     return false;
37809   }
37810 
37811   private boolean jj_3_51() {
37812     if (jj_3R_138()) return true;
37813     return false;
37814   }
37815 
37816   private boolean jj_3_50() {
37817     if (jj_3R_137()) return true;
37818     return false;
37819   }
37820 
37821   private boolean jj_3R_600() {
37822     if (jj_scan_token(3)) return true;
37823     if (jj_3R_124()) return true;
37824     return false;
37825   }
37826 
37827   private boolean jj_3R_221() {
37828     if (jj_scan_token(5)) return true;
37829     if (jj_3R_180()) return true;
37830     if (jj_scan_token(7)) return true;
37831     return false;
37832   }
37833 
37834   private boolean jj_3R_517() {
37835     if (jj_3R_124()) return true;
37836     return false;
37837   }
37838 
37839   private boolean jj_3R_462() {
37840     if (jj_3R_174()) return true;
37841     return false;
37842   }
37843 
37844   private boolean jj_3R_220() {
37845     if (jj_scan_token(WITH)) return true;
37846     if (jj_3R_180()) return true;
37847     return false;
37848   }
37849 
37850   private boolean jj_3R_461() {
37851     if (jj_3R_423()) return true;
37852     return false;
37853   }
37854 
37855   private boolean jj_3R_388() {
37856     if (jj_scan_token(USING)) return true;
37857     if (jj_3R_124()) return true;
37858     Token xsp;
37859     xsp = jj_scanpos;
37860     if (jj_3R_487()) jj_scanpos = xsp;
37861     return false;
37862   }
37863 
37864   private boolean jj_3R_219() {
37865     if (jj_scan_token(5)) return true;
37866     if (jj_3R_180()) return true;
37867     if (jj_scan_token(7)) return true;
37868     return false;
37869   }
37870 
37871   private boolean jj_3R_218() {
37872     if (jj_scan_token(SELECT)) return true;
37873     if (jj_3R_180()) return true;
37874     return false;
37875   }
37876 
37877   private boolean jj_3R_217() {
37878     if (jj_3R_295()) return true;
37879     return false;
37880   }
37881 
37882   private boolean jj_3R_475() {
37883     if (jj_3R_124()) return true;
37884     Token xsp;
37885     xsp = jj_scanpos;
37886     if (jj_3_25()) jj_scanpos = xsp;
37887     xsp = jj_scanpos;
37888     if (jj_scan_token(8)) {
37889     jj_scanpos = xsp;
37890     if (jj_3R_560()) return true;
37891     }
37892     xsp = jj_scanpos;
37893     if (jj_3R_561()) jj_scanpos = xsp;
37894     return false;
37895   }
37896 
37897   private boolean jj_3R_216() {
37898     if (jj_3R_140()) return true;
37899     return false;
37900   }
37901 
37902   private boolean jj_3R_215() {
37903     if (jj_3R_139()) return true;
37904     return false;
37905   }
37906 
37907   private boolean jj_3R_214() {
37908     if (jj_3R_138()) return true;
37909     return false;
37910   }
37911 
37912   private boolean jj_3R_213() {
37913     if (jj_3R_137()) return true;
37914     return false;
37915   }
37916 
37917   private boolean jj_3R_212() {
37918     if (jj_3R_294()) return true;
37919     return false;
37920   }
37921 
37922   private boolean jj_3R_516() {
37923     if (jj_scan_token(3)) return true;
37924     if (jj_3R_124()) return true;
37925     return false;
37926   }
37927 
37928   private boolean jj_3R_135() {
37929     Token xsp;
37930     xsp = jj_scanpos;
37931     if (jj_3R_212()) {
37932     jj_scanpos = xsp;
37933     if (jj_3R_213()) {
37934     jj_scanpos = xsp;
37935     if (jj_3R_214()) {
37936     jj_scanpos = xsp;
37937     if (jj_3R_215()) {
37938     jj_scanpos = xsp;
37939     if (jj_3R_216()) {
37940     jj_scanpos = xsp;
37941     if (jj_3R_217()) {
37942     jj_scanpos = xsp;
37943     if (jj_3R_218()) {
37944     jj_scanpos = xsp;
37945     if (jj_3R_219()) {
37946     jj_scanpos = xsp;
37947     if (jj_3R_220()) {
37948     jj_scanpos = xsp;
37949     if (jj_3R_221()) {
37950     jj_scanpos = xsp;
37951     if (jj_3R_222()) return true;
37952     }
37953     }
37954     }
37955     }
37956     }
37957     }
37958     }
37959     }
37960     }
37961     }
37962     return false;
37963   }
37964 
37965   private boolean jj_3R_332() {
37966     if (jj_3R_192()) return true;
37967     if (jj_scan_token(BEGIN)) return true;
37968     Token xsp;
37969     xsp = jj_scanpos;
37970     if (jj_3R_461()) jj_scanpos = xsp;
37971     while (true) {
37972       xsp = jj_scanpos;
37973       if (jj_3R_462()) { jj_scanpos = xsp; break; }
37974     }
37975     xsp = jj_scanpos;
37976     if (jj_3R_463()) jj_scanpos = xsp;
37977     if (jj_scan_token(END)) return true;
37978     xsp = jj_scanpos;
37979     if (jj_3R_464()) jj_scanpos = xsp;
37980     return false;
37981   }
37982 
37983   private boolean jj_3_49() {
37984     if (jj_3R_136()) return true;
37985     return false;
37986   }
37987 
37988   private boolean jj_3_48() {
37989     if (jj_scan_token(NEW)) return true;
37990     if (jj_3R_135()) return true;
37991     return false;
37992   }
37993 
37994   private boolean jj_3R_293() {
37995     if (jj_3R_135()) return true;
37996     return false;
37997   }
37998 
37999   private boolean jj_3_22() {
38000     if (jj_3R_124()) return true;
38001     if (jj_scan_token(3)) return true;
38002     return false;
38003   }
38004 
38005   private boolean jj_3_21() {
38006     if (jj_3R_123()) return true;
38007     return false;
38008   }
38009 
38010   private boolean jj_3R_155() {
38011     Token xsp;
38012     xsp = jj_scanpos;
38013     if (jj_3_22()) jj_scanpos = xsp;
38014     if (jj_3R_124()) return true;
38015     return false;
38016   }
38017 
38018   private boolean jj_3R_390() {
38019     if (jj_scan_token(RELIES_ON)) return true;
38020     if (jj_scan_token(5)) return true;
38021     if (jj_3R_124()) return true;
38022     Token xsp;
38023     xsp = jj_scanpos;
38024     if (jj_3R_600()) jj_scanpos = xsp;
38025     while (true) {
38026       xsp = jj_scanpos;
38027       if (jj_3R_601()) { jj_scanpos = xsp; break; }
38028     }
38029     if (jj_scan_token(7)) return true;
38030     return false;
38031   }
38032 
38033   private boolean jj_3R_387() {
38034     if (jj_3R_429()) return true;
38035     return false;
38036   }
38037 
38038   private boolean jj_3R_292() {
38039     if (jj_scan_token(NEW)) return true;
38040     if (jj_3R_135()) return true;
38041     return false;
38042   }
38043 
38044   private boolean jj_3R_431() {
38045     Token xsp;
38046     xsp = jj_scanpos;
38047     if (jj_scan_token(204)) {
38048     jj_scanpos = xsp;
38049     if (jj_scan_token(71)) return true;
38050     }
38051     xsp = jj_scanpos;
38052     if (jj_3R_517()) jj_scanpos = xsp;
38053     if (jj_scan_token(BY)) return true;
38054     if (jj_scan_token(5)) return true;
38055     if (jj_3R_124()) return true;
38056     while (true) {
38057       xsp = jj_scanpos;
38058       if (jj_3R_624()) { jj_scanpos = xsp; break; }
38059     }
38060     if (jj_scan_token(7)) return true;
38061     return false;
38062   }
38063 
38064   private boolean jj_3R_637() {
38065     if (jj_scan_token(6)) return true;
38066     Token xsp;
38067     xsp = jj_scanpos;
38068     if (jj_scan_token(198)) jj_scanpos = xsp;
38069     if (jj_3R_295()) return true;
38070     return false;
38071   }
38072 
38073   private boolean jj_3R_282() {
38074     Token xsp;
38075     xsp = jj_scanpos;
38076     if (jj_scan_token(152)) {
38077     jj_scanpos = xsp;
38078     if (jj_scan_token(51)) return true;
38079     }
38080     xsp = jj_scanpos;
38081     if (jj_3_21()) {
38082     jj_scanpos = xsp;
38083     if (jj_3R_332()) return true;
38084     }
38085     return false;
38086   }
38087 
38088   private boolean jj_3R_211() {
38089     Token xsp;
38090     xsp = jj_scanpos;
38091     if (jj_3R_292()) {
38092     jj_scanpos = xsp;
38093     if (jj_3R_293()) return true;
38094     }
38095     while (true) {
38096       xsp = jj_scanpos;
38097       if (jj_3_49()) { jj_scanpos = xsp; break; }
38098     }
38099     return false;
38100   }
38101 
38102   private boolean jj_3R_430() {
38103     if (jj_scan_token(USING)) return true;
38104     if (jj_3R_124()) return true;
38105     Token xsp;
38106     xsp = jj_scanpos;
38107     if (jj_3R_516()) jj_scanpos = xsp;
38108     return false;
38109   }
38110 
38111   private boolean jj_3R_389() {
38112     Token xsp;
38113     xsp = jj_scanpos;
38114     if (jj_3R_430()) {
38115     jj_scanpos = xsp;
38116     if (jj_3R_431()) return true;
38117     }
38118     return false;
38119   }
38120 
38121   private boolean jj_3R_210() {
38122     if (jj_scan_token(NEW_DOT)) return true;
38123     if (jj_3R_120()) return true;
38124     return false;
38125   }
38126 
38127   private boolean jj_3R_277() {
38128     Token xsp;
38129     xsp = jj_scanpos;
38130     if (jj_scan_token(100)) {
38131     jj_scanpos = xsp;
38132     if (jj_scan_token(182)) return true;
38133     }
38134     return false;
38135   }
38136 
38137   private boolean jj_3R_133() {
38138     Token xsp;
38139     xsp = jj_scanpos;
38140     if (jj_3R_210()) {
38141     jj_scanpos = xsp;
38142     if (jj_3R_211()) return true;
38143     }
38144     return false;
38145   }
38146 
38147   private boolean jj_3R_281() {
38148     if (jj_scan_token(AGGREGATE)) return true;
38149     if (jj_scan_token(USING)) return true;
38150     if (jj_3R_124()) return true;
38151     return false;
38152   }
38153 
38154   private boolean jj_3R_331() {
38155     if (jj_scan_token(RESULT_CACHE)) return true;
38156     Token xsp;
38157     xsp = jj_scanpos;
38158     if (jj_3R_390()) jj_scanpos = xsp;
38159     return false;
38160   }
38161 
38162   private boolean jj_3R_330() {
38163     if (jj_scan_token(PIPELINED)) return true;
38164     Token xsp;
38165     xsp = jj_scanpos;
38166     if (jj_3R_389()) jj_scanpos = xsp;
38167     return false;
38168   }
38169 
38170   private boolean jj_3_47() {
38171     if (jj_scan_token(IDENTIFIER)) return true;
38172     if (jj_scan_token(IS)) return true;
38173     return false;
38174   }
38175 
38176   private boolean jj_3R_329() {
38177     if (jj_scan_token(PARALLEL_ENABLE)) return true;
38178     Token xsp;
38179     xsp = jj_scanpos;
38180     if (jj_3R_387()) jj_scanpos = xsp;
38181     xsp = jj_scanpos;
38182     if (jj_3R_388()) jj_scanpos = xsp;
38183     return false;
38184   }
38185 
38186   private boolean jj_3R_328() {
38187     if (jj_3R_239()) return true;
38188     return false;
38189   }
38190 
38191   private boolean jj_3R_134() {
38192     if (jj_scan_token(NOT)) return true;
38193     if (jj_scan_token(NULL)) return true;
38194     return false;
38195   }
38196 
38197   private boolean jj_3R_635() {
38198     if (jj_3R_133()) return true;
38199     return false;
38200   }
38201 
38202   private boolean jj_3R_280() {
38203     Token xsp;
38204     xsp = jj_scanpos;
38205     if (jj_3R_327()) {
38206     jj_scanpos = xsp;
38207     if (jj_scan_token(95)) {
38208     jj_scanpos = xsp;
38209     if (jj_3R_328()) {
38210     jj_scanpos = xsp;
38211     if (jj_3R_329()) {
38212     jj_scanpos = xsp;
38213     if (jj_3R_330()) {
38214     jj_scanpos = xsp;
38215     if (jj_3R_331()) return true;
38216     }
38217     }
38218     }
38219     }
38220     }
38221     return false;
38222   }
38223 
38224   private boolean jj_3R_327() {
38225     if (jj_scan_token(AUTHID)) return true;
38226     Token xsp;
38227     xsp = jj_scanpos;
38228     if (jj_scan_token(37)) {
38229     jj_scanpos = xsp;
38230     if (jj_scan_token(36)) return true;
38231     }
38232     return false;
38233   }
38234 
38235   private boolean jj_3R_196() {
38236     Token xsp;
38237     while (true) {
38238       xsp = jj_scanpos;
38239       if (jj_3R_280()) { jj_scanpos = xsp; break; }
38240     }
38241     xsp = jj_scanpos;
38242     if (jj_3R_281()) jj_scanpos = xsp;
38243     xsp = jj_scanpos;
38244     if (jj_3R_282()) jj_scanpos = xsp;
38245     if (jj_scan_token(4)) return true;
38246     return false;
38247   }
38248 
38249   private boolean jj_3R_276() {
38250     if (jj_scan_token(OR)) return true;
38251     if (jj_scan_token(REPLACE)) return true;
38252     return false;
38253   }
38254 
38255   private boolean jj_3R_634() {
38256     if (jj_3R_295()) return true;
38257     if (jj_scan_token(IS)) return true;
38258     Token xsp;
38259     xsp = jj_scanpos;
38260     if (jj_3R_636()) jj_scanpos = xsp;
38261     if (jj_scan_token(OF)) return true;
38262     xsp = jj_scanpos;
38263     if (jj_scan_token(284)) jj_scanpos = xsp;
38264     if (jj_scan_token(5)) return true;
38265     xsp = jj_scanpos;
38266     if (jj_scan_token(198)) jj_scanpos = xsp;
38267     if (jj_3R_295()) return true;
38268     while (true) {
38269       xsp = jj_scanpos;
38270       if (jj_3R_637()) { jj_scanpos = xsp; break; }
38271     }
38272     if (jj_scan_token(7)) return true;
38273     return false;
38274   }
38275 
38276   private boolean jj_3R_632() {
38277     Token xsp;
38278     xsp = jj_scanpos;
38279     if (jj_3R_634()) {
38280     jj_scanpos = xsp;
38281     if (jj_3R_635()) return true;
38282     }
38283     return false;
38284   }
38285 
38286   private boolean jj_3R_195() {
38287     if (jj_3R_249()) return true;
38288     return false;
38289   }
38290 
38291   private boolean jj_3R_193() {
38292     if (jj_scan_token(CREATE)) return true;
38293     Token xsp;
38294     xsp = jj_scanpos;
38295     if (jj_3R_276()) jj_scanpos = xsp;
38296     xsp = jj_scanpos;
38297     if (jj_3R_277()) jj_scanpos = xsp;
38298     return false;
38299   }
38300 
38301   private boolean jj_3R_118() {
38302     Token xsp;
38303     xsp = jj_scanpos;
38304     if (jj_3R_193()) jj_scanpos = xsp;
38305     if (jj_3R_194()) return true;
38306     xsp = jj_scanpos;
38307     if (jj_3R_195()) {
38308     jj_scanpos = xsp;
38309     if (jj_3R_196()) return true;
38310     }
38311     return false;
38312   }
38313 
38314   private boolean jj_3_46() {
38315     if (jj_scan_token(IDENTIFIER)) return true;
38316     if (jj_scan_token(IS)) return true;
38317     Token xsp;
38318     xsp = jj_scanpos;
38319     if (jj_3R_134()) {
38320     jj_scanpos = xsp;
38321     if (jj_scan_token(185)) return true;
38322     }
38323     return false;
38324   }
38325 
38326   private boolean jj_3R_627() {
38327     if (jj_3R_632()) return true;
38328     return false;
38329   }
38330 
38331   private boolean jj_3R_626() {
38332     if (jj_3R_295()) return true;
38333     if (jj_scan_token(IS)) return true;
38334     Token xsp;
38335     xsp = jj_scanpos;
38336     if (jj_3R_631()) jj_scanpos = xsp;
38337     if (jj_scan_token(NULL)) return true;
38338     return false;
38339   }
38340 
38341   private boolean jj_3R_615() {
38342     Token xsp;
38343     xsp = jj_scanpos;
38344     if (jj_3R_626()) {
38345     jj_scanpos = xsp;
38346     if (jj_3R_627()) return true;
38347     }
38348     return false;
38349   }
38350 
38351   private boolean jj_3R_535() {
38352     if (jj_scan_token(CC_ERROR)) return true;
38353     if (jj_3R_234()) return true;
38354     if (jj_scan_token(CC_END)) return true;
38355     return false;
38356   }
38357 
38358   private boolean jj_3R_534() {
38359     if (jj_3R_323()) return true;
38360     return false;
38361   }
38362 
38363   private boolean jj_3R_506() {
38364     Token xsp;
38365     xsp = jj_scanpos;
38366     if (jj_3R_534()) {
38367     jj_scanpos = xsp;
38368     if (jj_3R_535()) return true;
38369     }
38370     return false;
38371   }
38372 
38373   private boolean jj_3R_474() {
38374     if (jj_scan_token(CC_ELSE)) return true;
38375     Token xsp;
38376     while (true) {
38377       xsp = jj_scanpos;
38378       if (jj_3R_506()) { jj_scanpos = xsp; break; }
38379     }
38380     return false;
38381   }
38382 
38383   private boolean jj_3R_533() {
38384     if (jj_scan_token(CC_ERROR)) return true;
38385     if (jj_3R_234()) return true;
38386     if (jj_scan_token(CC_END)) return true;
38387     return false;
38388   }
38389 
38390   private boolean jj_3R_590() {
38391     if (jj_3R_615()) return true;
38392     return false;
38393   }
38394 
38395   private boolean jj_3R_532() {
38396     if (jj_3R_323()) return true;
38397     return false;
38398   }
38399 
38400   private boolean jj_3R_505() {
38401     Token xsp;
38402     xsp = jj_scanpos;
38403     if (jj_3R_532()) {
38404     jj_scanpos = xsp;
38405     if (jj_3R_533()) return true;
38406     }
38407     return false;
38408   }
38409 
38410   private boolean jj_3R_589() {
38411     if (jj_scan_token(NOT)) return true;
38412     if (jj_3R_484()) return true;
38413     return false;
38414   }
38415 
38416   private boolean jj_3R_545() {
38417     Token xsp;
38418     xsp = jj_scanpos;
38419     if (jj_3R_589()) {
38420     jj_scanpos = xsp;
38421     if (jj_3R_590()) return true;
38422     }
38423     return false;
38424   }
38425 
38426   private boolean jj_3R_473() {
38427     if (jj_scan_token(CC_ELSIF)) return true;
38428     if (jj_3R_344()) return true;
38429     if (jj_scan_token(CC_THEN)) return true;
38430     Token xsp;
38431     while (true) {
38432       xsp = jj_scanpos;
38433       if (jj_3R_505()) { jj_scanpos = xsp; break; }
38434     }
38435     return false;
38436   }
38437 
38438   private boolean jj_3R_504() {
38439     if (jj_scan_token(CC_ERROR)) return true;
38440     if (jj_3R_234()) return true;
38441     if (jj_scan_token(CC_END)) return true;
38442     return false;
38443   }
38444 
38445   private boolean jj_3R_254() {
38446     if (jj_3R_124()) return true;
38447     return false;
38448   }
38449 
38450   private boolean jj_3R_503() {
38451     if (jj_3R_323()) return true;
38452     return false;
38453   }
38454 
38455   private boolean jj_3R_472() {
38456     Token xsp;
38457     xsp = jj_scanpos;
38458     if (jj_3R_503()) {
38459     jj_scanpos = xsp;
38460     if (jj_3R_504()) return true;
38461     }
38462     return false;
38463   }
38464 
38465   private boolean jj_3R_514() {
38466     if (jj_3R_545()) return true;
38467     return false;
38468   }
38469 
38470   private boolean jj_3R_544() {
38471     if (jj_scan_token(17)) return true;
38472     return false;
38473   }
38474 
38475   private boolean jj_3R_543() {
38476     if (jj_scan_token(16)) return true;
38477     return false;
38478   }
38479 
38480   private boolean jj_3R_513() {
38481     Token xsp;
38482     xsp = jj_scanpos;
38483     if (jj_3R_543()) {
38484     jj_scanpos = xsp;
38485     if (jj_3R_544()) return true;
38486     }
38487     if (jj_3R_484()) return true;
38488     return false;
38489   }
38490 
38491   private boolean jj_3R_427() {
38492     if (jj_scan_token(CC_IF)) return true;
38493     if (jj_3R_344()) return true;
38494     if (jj_scan_token(CC_THEN)) return true;
38495     Token xsp;
38496     while (true) {
38497       xsp = jj_scanpos;
38498       if (jj_3R_472()) { jj_scanpos = xsp; break; }
38499     }
38500     while (true) {
38501       xsp = jj_scanpos;
38502       if (jj_3R_473()) { jj_scanpos = xsp; break; }
38503     }
38504     while (true) {
38505       xsp = jj_scanpos;
38506       if (jj_3R_474()) { jj_scanpos = xsp; break; }
38507     }
38508     if (jj_scan_token(CC_END)) return true;
38509     return false;
38510   }
38511 
38512   private boolean jj_3R_275() {
38513     if (jj_3R_323()) return true;
38514     return false;
38515   }
38516 
38517   private boolean jj_3R_484() {
38518     Token xsp;
38519     xsp = jj_scanpos;
38520     if (jj_3R_513()) {
38521     jj_scanpos = xsp;
38522     if (jj_3R_514()) return true;
38523     }
38524     return false;
38525   }
38526 
38527   private boolean jj_3R_385() {
38528     if (jj_3R_427()) return true;
38529     return false;
38530   }
38531 
38532   private boolean jj_3R_192() {
38533     Token xsp;
38534     while (true) {
38535       xsp = jj_scanpos;
38536       if (jj_3R_275()) { jj_scanpos = xsp; break; }
38537     }
38538     return false;
38539   }
38540 
38541   private boolean jj_3R_608() {
38542     if (jj_scan_token(MOD)) return true;
38543     return false;
38544   }
38545 
38546   private boolean jj_3R_384() {
38547     if (jj_3R_426()) return true;
38548     return false;
38549   }
38550 
38551   private boolean jj_3_18() {
38552     Token xsp;
38553     xsp = jj_scanpos;
38554     if (jj_scan_token(125)) {
38555     jj_scanpos = xsp;
38556     if (jj_scan_token(223)) return true;
38557     }
38558     if (jj_3R_120()) return true;
38559     return false;
38560   }
38561 
38562   private boolean jj_3R_607() {
38563     if (jj_scan_token(1)) return true;
38564     return false;
38565   }
38566 
38567   private boolean jj_3R_606() {
38568     if (jj_scan_token(20)) return true;
38569     return false;
38570   }
38571 
38572   private boolean jj_3_17() {
38573     Token xsp;
38574     xsp = jj_scanpos;
38575     if (jj_scan_token(284)) {
38576     jj_scanpos = xsp;
38577     if (jj_scan_token(264)) return true;
38578     }
38579     if (jj_3R_120()) return true;
38580     xsp = jj_scanpos;
38581     if (jj_scan_token(152)) {
38582     jj_scanpos = xsp;
38583     if (jj_scan_token(51)) return true;
38584     }
38585     return false;
38586   }
38587 
38588   private boolean jj_3R_605() {
38589     if (jj_scan_token(19)) return true;
38590     return false;
38591   }
38592 
38593   private boolean jj_3R_383() {
38594     if (jj_3R_425()) return true;
38595     return false;
38596   }
38597 
38598   private boolean jj_3R_382() {
38599     if (jj_3R_424()) return true;
38600     return false;
38601   }
38602 
38603   private boolean jj_3R_570() {
38604     Token xsp;
38605     xsp = jj_scanpos;
38606     if (jj_3R_605()) {
38607     jj_scanpos = xsp;
38608     if (jj_3R_606()) {
38609     jj_scanpos = xsp;
38610     if (jj_3R_607()) {
38611     jj_scanpos = xsp;
38612     if (jj_3R_608()) return true;
38613     }
38614     }
38615     }
38616     if (jj_3R_484()) return true;
38617     return false;
38618   }
38619 
38620   private boolean jj_3_20() {
38621     if (jj_3R_122()) return true;
38622     return false;
38623   }
38624 
38625   private boolean jj_3R_307() {
38626     if (jj_3R_351()) return true;
38627     return false;
38628   }
38629 
38630   private boolean jj_3_19() {
38631     if (jj_3R_121()) return true;
38632     return false;
38633   }
38634 
38635   private boolean jj_3R_381() {
38636     if (jj_3R_118()) return true;
38637     return false;
38638   }
38639 
38640   private boolean jj_3R_380() {
38641     if (jj_3R_153()) return true;
38642     return false;
38643   }
38644 
38645   private boolean jj_3R_537() {
38646     if (jj_3R_484()) return true;
38647     Token xsp;
38648     while (true) {
38649       xsp = jj_scanpos;
38650       if (jj_3R_570()) { jj_scanpos = xsp; break; }
38651     }
38652     return false;
38653   }
38654 
38655   private boolean jj_3_16() {
38656     if (jj_3R_119()) return true;
38657     return false;
38658   }
38659 
38660   private boolean jj_3R_379() {
38661     if (jj_3R_423()) return true;
38662     return false;
38663   }
38664 
38665   private boolean jj_3_15() {
38666     if (jj_3R_118()) return true;
38667     return false;
38668   }
38669 
38670   private boolean jj_3R_252() {
38671     Token xsp;
38672     xsp = jj_scanpos;
38673     if (jj_scan_token(100)) {
38674     jj_scanpos = xsp;
38675     if (jj_scan_token(182)) return true;
38676     }
38677     return false;
38678   }
38679 
38680   private boolean jj_3R_300() {
38681     if (jj_scan_token(18)) return true;
38682     if (jj_3R_133()) return true;
38683     return false;
38684   }
38685 
38686   private boolean jj_3R_306() {
38687     if (jj_3R_174()) return true;
38688     return false;
38689   }
38690 
38691   private boolean jj_3R_323() {
38692     Token xsp;
38693     xsp = jj_scanpos;
38694     if (jj_3R_379()) {
38695     jj_scanpos = xsp;
38696     if (jj_3_16()) {
38697     jj_scanpos = xsp;
38698     if (jj_3R_380()) {
38699     jj_scanpos = xsp;
38700     if (jj_3R_381()) {
38701     jj_scanpos = xsp;
38702     if (jj_3_19()) {
38703     jj_scanpos = xsp;
38704     if (jj_3_20()) {
38705     jj_scanpos = xsp;
38706     if (jj_3R_382()) {
38707     jj_scanpos = xsp;
38708     if (jj_3R_383()) {
38709     jj_scanpos = xsp;
38710     if (jj_3R_384()) {
38711     jj_scanpos = xsp;
38712     if (jj_3R_385()) return true;
38713     }
38714     }
38715     }
38716     }
38717     }
38718     }
38719     }
38720     }
38721     }
38722     return false;
38723   }
38724 
38725   private boolean jj_3R_230() {
38726     if (jj_3R_133()) return true;
38727     Token xsp;
38728     while (true) {
38729       xsp = jj_scanpos;
38730       if (jj_3R_300()) { jj_scanpos = xsp; break; }
38731     }
38732     return false;
38733   }
38734 
38735   private boolean jj_3R_253() {
38736     if (jj_scan_token(BEGIN)) return true;
38737     Token xsp;
38738     while (true) {
38739       xsp = jj_scanpos;
38740       if (jj_3R_306()) { jj_scanpos = xsp; break; }
38741     }
38742     xsp = jj_scanpos;
38743     if (jj_3R_307()) jj_scanpos = xsp;
38744     return false;
38745   }
38746 
38747   private boolean jj_3R_573() {
38748     if (jj_scan_token(18)) return true;
38749     return false;
38750   }
38751 
38752   private boolean jj_3R_572() {
38753     if (jj_scan_token(17)) return true;
38754     return false;
38755   }
38756 
38757   private boolean jj_3R_571() {
38758     if (jj_scan_token(16)) return true;
38759     return false;
38760   }
38761 
38762   private boolean jj_3R_251() {
38763     if (jj_scan_token(OR)) return true;
38764     if (jj_scan_token(REPLACE)) return true;
38765     return false;
38766   }
38767 
38768   private boolean jj_3R_161() {
38769     Token xsp;
38770     xsp = jj_scanpos;
38771     if (jj_scan_token(152)) {
38772     jj_scanpos = xsp;
38773     if (jj_scan_token(51)) return true;
38774     }
38775     if (jj_3R_192()) return true;
38776     xsp = jj_scanpos;
38777     if (jj_3R_253()) jj_scanpos = xsp;
38778     if (jj_scan_token(END)) return true;
38779     xsp = jj_scanpos;
38780     if (jj_3R_254()) jj_scanpos = xsp;
38781     if (jj_scan_token(4)) return true;
38782     return false;
38783   }
38784 
38785   private boolean jj_3R_538() {
38786     Token xsp;
38787     xsp = jj_scanpos;
38788     if (jj_3R_571()) {
38789     jj_scanpos = xsp;
38790     if (jj_3R_572()) {
38791     jj_scanpos = xsp;
38792     if (jj_3R_573()) return true;
38793     }
38794     }
38795     if (jj_3R_537()) return true;
38796     return false;
38797   }
38798 
38799   private boolean jj_3R_160() {
38800     if (jj_3R_249()) return true;
38801     return false;
38802   }
38803 
38804   private boolean jj_3R_271() {
38805     if (jj_3R_191()) return true;
38806     return false;
38807   }
38808 
38809   private boolean jj_3R_508() {
38810     if (jj_3R_537()) return true;
38811     Token xsp;
38812     while (true) {
38813       xsp = jj_scanpos;
38814       if (jj_3R_538()) { jj_scanpos = xsp; break; }
38815     }
38816     return false;
38817   }
38818 
38819   private boolean jj_3R_588() {
38820     if (jj_3R_183()) return true;
38821     return false;
38822   }
38823 
38824   private boolean jj_3R_159() {
38825     if (jj_scan_token(CREATE)) return true;
38826     Token xsp;
38827     xsp = jj_scanpos;
38828     if (jj_3R_251()) jj_scanpos = xsp;
38829     xsp = jj_scanpos;
38830     if (jj_3R_252()) jj_scanpos = xsp;
38831     return false;
38832   }
38833 
38834   private boolean jj_3R_202() {
38835     if (jj_3R_283()) return true;
38836     return false;
38837   }
38838 
38839   private boolean jj_3R_587() {
38840     if (jj_scan_token(CHARACTER_LITERAL)) return true;
38841     return false;
38842   }
38843 
38844   private boolean jj_3R_246() {
38845     Token xsp;
38846     xsp = jj_scanpos;
38847     if (jj_scan_token(100)) {
38848     jj_scanpos = xsp;
38849     if (jj_scan_token(182)) return true;
38850     }
38851     return false;
38852   }
38853 
38854   private boolean jj_3R_250() {
38855     if (jj_3R_124()) return true;
38856     return false;
38857   }
38858 
38859   private boolean jj_3R_542() {
38860     if (jj_scan_token(ESCAPE)) return true;
38861     Token xsp;
38862     xsp = jj_scanpos;
38863     if (jj_3R_587()) {
38864     jj_scanpos = xsp;
38865     if (jj_3R_588()) return true;
38866     }
38867     return false;
38868   }
38869 
38870   private boolean jj_3R_104() {
38871     Token xsp;
38872     xsp = jj_scanpos;
38873     if (jj_3R_159()) jj_scanpos = xsp;
38874     xsp = jj_scanpos;
38875     if (jj_scan_token(209)) {
38876     jj_scanpos = xsp;
38877     if (jj_scan_token(284)) return true;
38878     }
38879     if (jj_scan_token(BODY)) return true;
38880     if (jj_3R_155()) return true;
38881     xsp = jj_scanpos;
38882     if (jj_3R_160()) {
38883     jj_scanpos = xsp;
38884     if (jj_3R_161()) return true;
38885     }
38886     return false;
38887   }
38888 
38889   private boolean jj_3R_614() {
38890     if (jj_scan_token(ALL)) return true;
38891     return false;
38892   }
38893 
38894   private boolean jj_3R_613() {
38895     if (jj_scan_token(DISTINCT)) return true;
38896     return false;
38897   }
38898 
38899   private boolean jj_3R_586() {
38900     Token xsp;
38901     xsp = jj_scanpos;
38902     if (jj_3R_613()) {
38903     jj_scanpos = xsp;
38904     if (jj_3R_614()) return true;
38905     }
38906     return false;
38907   }
38908 
38909   private boolean jj_3R_585() {
38910     if (jj_scan_token(UNION)) return true;
38911     return false;
38912   }
38913 
38914   private boolean jj_3R_584() {
38915     if (jj_scan_token(INTERSECT)) return true;
38916     return false;
38917   }
38918 
38919   private boolean jj_3R_124() {
38920     Token xsp;
38921     xsp = jj_scanpos;
38922     if (jj_scan_token(420)) {
38923     jj_scanpos = xsp;
38924     if (jj_scan_token(428)) {
38925     jj_scanpos = xsp;
38926     if (jj_3R_202()) {
38927     jj_scanpos = xsp;
38928     if (jj_scan_token(35)) {
38929     jj_scanpos = xsp;
38930     if (jj_scan_token(38)) {
38931     jj_scanpos = xsp;
38932     if (jj_scan_token(39)) {
38933     jj_scanpos = xsp;
38934     if (jj_scan_token(40)) {
38935     jj_scanpos = xsp;
38936     if (jj_scan_token(41)) {
38937     jj_scanpos = xsp;
38938     if (jj_scan_token(46)) {
38939     jj_scanpos = xsp;
38940     if (jj_scan_token(47)) {
38941     jj_scanpos = xsp;
38942     if (jj_scan_token(48)) {
38943     jj_scanpos = xsp;
38944     if (jj_scan_token(49)) {
38945     jj_scanpos = xsp;
38946     if (jj_scan_token(50)) {
38947     jj_scanpos = xsp;
38948     if (jj_scan_token(51)) {
38949     jj_scanpos = xsp;
38950     if (jj_scan_token(52)) {
38951     jj_scanpos = xsp;
38952     if (jj_scan_token(56)) {
38953     jj_scanpos = xsp;
38954     if (jj_scan_token(58)) {
38955     jj_scanpos = xsp;
38956     if (jj_scan_token(59)) {
38957     jj_scanpos = xsp;
38958     if (jj_scan_token(60)) {
38959     jj_scanpos = xsp;
38960     if (jj_scan_token(61)) {
38961     jj_scanpos = xsp;
38962     if (jj_scan_token(63)) {
38963     jj_scanpos = xsp;
38964     if (jj_scan_token(66)) {
38965     jj_scanpos = xsp;
38966     if (jj_scan_token(67)) {
38967     jj_scanpos = xsp;
38968     if (jj_scan_token(68)) {
38969     jj_scanpos = xsp;
38970     if (jj_scan_token(69)) {
38971     jj_scanpos = xsp;
38972     if (jj_scan_token(71)) {
38973     jj_scanpos = xsp;
38974     if (jj_scan_token(77)) {
38975     jj_scanpos = xsp;
38976     if (jj_scan_token(78)) {
38977     jj_scanpos = xsp;
38978     if (jj_scan_token(79)) {
38979     jj_scanpos = xsp;
38980     if (jj_scan_token(83)) {
38981     jj_scanpos = xsp;
38982     if (jj_scan_token(85)) {
38983     jj_scanpos = xsp;
38984     if (jj_scan_token(88)) {
38985     jj_scanpos = xsp;
38986     if (jj_scan_token(90)) {
38987     jj_scanpos = xsp;
38988     if (jj_scan_token(91)) {
38989     jj_scanpos = xsp;
38990     if (jj_scan_token(92)) {
38991     jj_scanpos = xsp;
38992     if (jj_scan_token(93)) {
38993     jj_scanpos = xsp;
38994     if (jj_scan_token(94)) {
38995     jj_scanpos = xsp;
38996     if (jj_scan_token(97)) {
38997     jj_scanpos = xsp;
38998     if (jj_scan_token(98)) {
38999     jj_scanpos = xsp;
39000     if (jj_scan_token(99)) {
39001     jj_scanpos = xsp;
39002     if (jj_scan_token(102)) {
39003     jj_scanpos = xsp;
39004     if (jj_scan_token(103)) {
39005     jj_scanpos = xsp;
39006     if (jj_scan_token(108)) {
39007     jj_scanpos = xsp;
39008     if (jj_scan_token(110)) {
39009     jj_scanpos = xsp;
39010     if (jj_scan_token(111)) {
39011     jj_scanpos = xsp;
39012     if (jj_scan_token(112)) {
39013     jj_scanpos = xsp;
39014     if (jj_scan_token(118)) {
39015     jj_scanpos = xsp;
39016     if (jj_scan_token(120)) {
39017     jj_scanpos = xsp;
39018     if (jj_scan_token(121)) {
39019     jj_scanpos = xsp;
39020     if (jj_scan_token(122)) {
39021     jj_scanpos = xsp;
39022     if (jj_scan_token(124)) {
39023     jj_scanpos = xsp;
39024     if (jj_scan_token(127)) {
39025     jj_scanpos = xsp;
39026     if (jj_scan_token(128)) {
39027     jj_scanpos = xsp;
39028     if (jj_scan_token(131)) {
39029     jj_scanpos = xsp;
39030     if (jj_scan_token(135)) {
39031     jj_scanpos = xsp;
39032     if (jj_scan_token(137)) {
39033     jj_scanpos = xsp;
39034     if (jj_scan_token(139)) {
39035     jj_scanpos = xsp;
39036     if (jj_scan_token(144)) {
39037     jj_scanpos = xsp;
39038     if (jj_scan_token(146)) {
39039     jj_scanpos = xsp;
39040     if (jj_scan_token(147)) {
39041     jj_scanpos = xsp;
39042     if (jj_scan_token(148)) {
39043     jj_scanpos = xsp;
39044     if (jj_scan_token(150)) {
39045     jj_scanpos = xsp;
39046     if (jj_scan_token(152)) {
39047     jj_scanpos = xsp;
39048     if (jj_scan_token(156)) {
39049     jj_scanpos = xsp;
39050     if (jj_scan_token(158)) {
39051     jj_scanpos = xsp;
39052     if (jj_scan_token(159)) {
39053     jj_scanpos = xsp;
39054     if (jj_scan_token(160)) {
39055     jj_scanpos = xsp;
39056     if (jj_scan_token(161)) {
39057     jj_scanpos = xsp;
39058     if (jj_scan_token(167)) {
39059     jj_scanpos = xsp;
39060     if (jj_scan_token(171)) {
39061     jj_scanpos = xsp;
39062     if (jj_scan_token(172)) {
39063     jj_scanpos = xsp;
39064     if (jj_scan_token(175)) {
39065     jj_scanpos = xsp;
39066     if (jj_scan_token(178)) {
39067     jj_scanpos = xsp;
39068     if (jj_scan_token(181)) {
39069     jj_scanpos = xsp;
39070     if (jj_scan_token(183)) {
39071     jj_scanpos = xsp;
39072     if (jj_scan_token(184)) {
39073     jj_scanpos = xsp;
39074     if (jj_scan_token(185)) {
39075     jj_scanpos = xsp;
39076     if (jj_scan_token(187)) {
39077     jj_scanpos = xsp;
39078     if (jj_scan_token(192)) {
39079     jj_scanpos = xsp;
39080     if (jj_scan_token(194)) {
39081     jj_scanpos = xsp;
39082     if (jj_scan_token(195)) {
39083     jj_scanpos = xsp;
39084     if (jj_scan_token(197)) {
39085     jj_scanpos = xsp;
39086     if (jj_scan_token(188)) {
39087     jj_scanpos = xsp;
39088     if (jj_scan_token(189)) {
39089     jj_scanpos = xsp;
39090     if (jj_scan_token(190)) {
39091     jj_scanpos = xsp;
39092     if (jj_scan_token(191)) {
39093     jj_scanpos = xsp;
39094     if (jj_scan_token(201)) {
39095     jj_scanpos = xsp;
39096     if (jj_scan_token(202)) {
39097     jj_scanpos = xsp;
39098     if (jj_scan_token(203)) {
39099     jj_scanpos = xsp;
39100     if (jj_scan_token(204)) {
39101     jj_scanpos = xsp;
39102     if (jj_scan_token(207)) {
39103     jj_scanpos = xsp;
39104     if (jj_scan_token(212)) {
39105     jj_scanpos = xsp;
39106     if (jj_scan_token(215)) {
39107     jj_scanpos = xsp;
39108     if (jj_scan_token(216)) {
39109     jj_scanpos = xsp;
39110     if (jj_scan_token(217)) {
39111     jj_scanpos = xsp;
39112     if (jj_scan_token(220)) {
39113     jj_scanpos = xsp;
39114     if (jj_scan_token(222)) {
39115     jj_scanpos = xsp;
39116     if (jj_scan_token(221)) {
39117     jj_scanpos = xsp;
39118     if (jj_scan_token(224)) {
39119     jj_scanpos = xsp;
39120     if (jj_scan_token(225)) {
39121     jj_scanpos = xsp;
39122     if (jj_scan_token(227)) {
39123     jj_scanpos = xsp;
39124     if (jj_scan_token(246)) {
39125     jj_scanpos = xsp;
39126     if (jj_scan_token(250)) {
39127     jj_scanpos = xsp;
39128     if (jj_scan_token(252)) {
39129     jj_scanpos = xsp;
39130     if (jj_scan_token(255)) {
39131     jj_scanpos = xsp;
39132     if (jj_scan_token(256)) {
39133     jj_scanpos = xsp;
39134     if (jj_scan_token(258)) {
39135     jj_scanpos = xsp;
39136     if (jj_scan_token(259)) {
39137     jj_scanpos = xsp;
39138     if (jj_scan_token(260)) {
39139     jj_scanpos = xsp;
39140     if (jj_scan_token(261)) {
39141     jj_scanpos = xsp;
39142     if (jj_scan_token(263)) {
39143     jj_scanpos = xsp;
39144     if (jj_scan_token(267)) {
39145     jj_scanpos = xsp;
39146     if (jj_scan_token(268)) {
39147     jj_scanpos = xsp;
39148     if (jj_scan_token(269)) {
39149     jj_scanpos = xsp;
39150     if (jj_scan_token(271)) {
39151     jj_scanpos = xsp;
39152     if (jj_scan_token(273)) {
39153     jj_scanpos = xsp;
39154     if (jj_scan_token(280)) {
39155     jj_scanpos = xsp;
39156     if (jj_scan_token(282)) {
39157     jj_scanpos = xsp;
39158     if (jj_scan_token(284)) {
39159     jj_scanpos = xsp;
39160     if (jj_scan_token(285)) {
39161     jj_scanpos = xsp;
39162     if (jj_scan_token(297)) {
39163     jj_scanpos = xsp;
39164     if (jj_scan_token(298)) {
39165     jj_scanpos = xsp;
39166     if (jj_scan_token(299)) {
39167     jj_scanpos = xsp;
39168     if (jj_scan_token(303)) {
39169     jj_scanpos = xsp;
39170     if (jj_scan_token(305)) {
39171     jj_scanpos = xsp;
39172     if (jj_scan_token(308)) {
39173     jj_scanpos = xsp;
39174     if (jj_scan_token(318)) {
39175     jj_scanpos = xsp;
39176     if (jj_scan_token(292)) {
39177     jj_scanpos = xsp;
39178     if (jj_scan_token(432)) {
39179     jj_scanpos = xsp;
39180     if (jj_scan_token(429)) {
39181     jj_scanpos = xsp;
39182     if (jj_scan_token(430)) {
39183     jj_scanpos = xsp;
39184     if (jj_scan_token(431)) return true;
39185     }
39186     }
39187     }
39188     }
39189     }
39190     }
39191     }
39192     }
39193     }
39194     }
39195     }
39196     }
39197     }
39198     }
39199     }
39200     }
39201     }
39202     }
39203     }
39204     }
39205     }
39206     }
39207     }
39208     }
39209     }
39210     }
39211     }
39212     }
39213     }
39214     }
39215     }
39216     }
39217     }
39218     }
39219     }
39220     }
39221     }
39222     }
39223     }
39224     }
39225     }
39226     }
39227     }
39228     }
39229     }
39230     }
39231     }
39232     }
39233     }
39234     }
39235     }
39236     }
39237     }
39238     }
39239     }
39240     }
39241     }
39242     }
39243     }
39244     }
39245     }
39246     }
39247     }
39248     }
39249     }
39250     }
39251     }
39252     }
39253     }
39254     }
39255     }
39256     }
39257     }
39258     }
39259     }
39260     }
39261     }
39262     }
39263     }
39264     }
39265     }
39266     }
39267     }
39268     }
39269     }
39270     }
39271     }
39272     }
39273     }
39274     }
39275     }
39276     }
39277     }
39278     }
39279     }
39280     }
39281     }
39282     }
39283     }
39284     }
39285     }
39286     }
39287     }
39288     }
39289     }
39290     }
39291     }
39292     }
39293     }
39294     }
39295     }
39296     }
39297     }
39298     }
39299     }
39300     }
39301     }
39302     }
39303     }
39304     }
39305     }
39306     }
39307     }
39308     }
39309     }
39310     }
39311     }
39312     }
39313     }
39314     }
39315     }
39316     return false;
39317   }
39318 
39319   private boolean jj_3R_583() {
39320     if (jj_scan_token(EXCEPT)) return true;
39321     return false;
39322   }
39323 
39324   private boolean jj_3R_158() {
39325     Token xsp;
39326     xsp = jj_scanpos;
39327     if (jj_scan_token(152)) {
39328     jj_scanpos = xsp;
39329     if (jj_scan_token(51)) return true;
39330     }
39331     if (jj_3R_192()) return true;
39332     if (jj_scan_token(END)) return true;
39333     xsp = jj_scanpos;
39334     if (jj_3R_250()) jj_scanpos = xsp;
39335     if (jj_scan_token(4)) return true;
39336     return false;
39337   }
39338 
39339   private boolean jj_3R_612() {
39340     if (jj_scan_token(OF)) return true;
39341     return false;
39342   }
39343 
39344   private boolean jj_3R_541() {
39345     if (jj_scan_token(MULTISET)) return true;
39346     Token xsp;
39347     xsp = jj_scanpos;
39348     if (jj_3R_583()) {
39349     jj_scanpos = xsp;
39350     if (jj_3R_584()) {
39351     jj_scanpos = xsp;
39352     if (jj_3R_585()) return true;
39353     }
39354     }
39355     xsp = jj_scanpos;
39356     if (jj_3R_586()) jj_scanpos = xsp;
39357     return false;
39358   }
39359 
39360   private boolean jj_3R_157() {
39361     if (jj_3R_249()) return true;
39362     return false;
39363   }
39364 
39365   private boolean jj_3R_245() {
39366     if (jj_scan_token(OR)) return true;
39367     if (jj_scan_token(REPLACE)) return true;
39368     return false;
39369   }
39370 
39371   private boolean jj_3R_611() {
39372     if (jj_scan_token(SUBMULTISET)) return true;
39373     return false;
39374   }
39375 
39376   private boolean jj_3R_248() {
39377     if (jj_3R_239()) return true;
39378     return false;
39379   }
39380 
39381   private boolean jj_3R_610() {
39382     if (jj_scan_token(MEMBER)) return true;
39383     return false;
39384   }
39385 
39386   private boolean jj_3R_156() {
39387     Token xsp;
39388     xsp = jj_scanpos;
39389     if (jj_3R_247()) {
39390     jj_scanpos = xsp;
39391     if (jj_3R_248()) return true;
39392     }
39393     return false;
39394   }
39395 
39396   private boolean jj_3R_247() {
39397     if (jj_scan_token(AUTHID)) return true;
39398     Token xsp;
39399     xsp = jj_scanpos;
39400     if (jj_scan_token(37)) {
39401     jj_scanpos = xsp;
39402     if (jj_scan_token(36)) return true;
39403     }
39404     return false;
39405   }
39406 
39407   private boolean jj_3R_582() {
39408     Token xsp;
39409     xsp = jj_scanpos;
39410     if (jj_3R_610()) {
39411     jj_scanpos = xsp;
39412     if (jj_3R_611()) return true;
39413     }
39414     xsp = jj_scanpos;
39415     if (jj_3R_612()) jj_scanpos = xsp;
39416     return false;
39417   }
39418 
39419   private boolean jj_3R_581() {
39420     if (jj_scan_token(FROM)) return true;
39421     return false;
39422   }
39423 
39424   private boolean jj_3R_154() {
39425     if (jj_scan_token(CREATE)) return true;
39426     Token xsp;
39427     xsp = jj_scanpos;
39428     if (jj_3R_245()) jj_scanpos = xsp;
39429     xsp = jj_scanpos;
39430     if (jj_3R_246()) jj_scanpos = xsp;
39431     return false;
39432   }
39433 
39434   private boolean jj_3R_580() {
39435     if (jj_scan_token(LIKE)) return true;
39436     return false;
39437   }
39438 
39439   private boolean jj_3R_579() {
39440     if (jj_scan_token(BETWEEN)) return true;
39441     return false;
39442   }
39443 
39444   private boolean jj_3R_578() {
39445     if (jj_scan_token(IN)) return true;
39446     return false;
39447   }
39448 
39449   private boolean jj_3R_103() {
39450     Token xsp;
39451     xsp = jj_scanpos;
39452     if (jj_3R_154()) jj_scanpos = xsp;
39453     if (jj_scan_token(PACKAGE)) return true;
39454     if (jj_3R_155()) return true;
39455     while (true) {
39456       xsp = jj_scanpos;
39457       if (jj_3R_156()) { jj_scanpos = xsp; break; }
39458     }
39459     xsp = jj_scanpos;
39460     if (jj_3R_157()) {
39461     jj_scanpos = xsp;
39462     if (jj_3R_158()) return true;
39463     }
39464     return false;
39465   }
39466 
39467   private boolean jj_3R_609() {
39468     if (jj_scan_token(15)) return true;
39469     return false;
39470   }
39471 
39472   private boolean jj_3R_577() {
39473     if (jj_scan_token(NOT)) return true;
39474     return false;
39475   }
39476 
39477   private boolean jj_3R_576() {
39478     if (jj_scan_token(10)) return true;
39479     return false;
39480   }
39481 
39482   private boolean jj_3R_575() {
39483     if (jj_scan_token(15)) return true;
39484     return false;
39485   }
39486 
39487   private boolean jj_3R_540() {
39488     Token xsp;
39489     xsp = jj_scanpos;
39490     if (jj_3R_577()) jj_scanpos = xsp;
39491     xsp = jj_scanpos;
39492     if (jj_3R_578()) {
39493     jj_scanpos = xsp;
39494     if (jj_3R_579()) {
39495     jj_scanpos = xsp;
39496     if (jj_3R_580()) {
39497     jj_scanpos = xsp;
39498     if (jj_3R_581()) {
39499     jj_scanpos = xsp;
39500     if (jj_3R_582()) return true;
39501     }
39502     }
39503     }
39504     }
39505     return false;
39506   }
39507 
39508   private boolean jj_3R_574() {
39509     if (jj_scan_token(14)) return true;
39510     Token xsp;
39511     xsp = jj_scanpos;
39512     if (jj_3R_609()) jj_scanpos = xsp;
39513     return false;
39514   }
39515 
39516   private boolean jj_3R_117() {
39517     if (jj_scan_token(DECLARE)) return true;
39518     if (jj_3R_192()) return true;
39519     return false;
39520   }
39521 
39522   private boolean jj_3R_539() {
39523     Token xsp;
39524     xsp = jj_scanpos;
39525     if (jj_3R_574()) {
39526     jj_scanpos = xsp;
39527     if (jj_3R_575()) return true;
39528     }
39529     xsp = jj_scanpos;
39530     if (jj_3R_576()) jj_scanpos = xsp;
39531     return false;
39532   }
39533 
39534   private boolean jj_3R_322() {
39535     if (jj_3R_351()) return true;
39536     return false;
39537   }
39538 
39539   private boolean jj_3R_321() {
39540     if (jj_3R_174()) return true;
39541     return false;
39542   }
39543 
39544   private boolean jj_3R_509() {
39545     Token xsp;
39546     xsp = jj_scanpos;
39547     if (jj_3R_539()) {
39548     jj_scanpos = xsp;
39549     if (jj_3R_540()) {
39550     jj_scanpos = xsp;
39551     if (jj_3R_541()) return true;
39552     }
39553     }
39554     if (jj_3R_508()) return true;
39555     xsp = jj_scanpos;
39556     if (jj_3R_542()) jj_scanpos = xsp;
39557     return false;
39558   }
39559 
39560   private boolean jj_3R_116() {
39561     if (jj_3R_191()) return true;
39562     return false;
39563   }
39564 
39565   private boolean jj_3_14() {
39566     Token xsp;
39567     while (true) {
39568       xsp = jj_scanpos;
39569       if (jj_3R_116()) { jj_scanpos = xsp; break; }
39570     }
39571     xsp = jj_scanpos;
39572     if (jj_3R_117()) jj_scanpos = xsp;
39573     if (jj_scan_token(BEGIN)) return true;
39574     return false;
39575   }
39576 
39577   private boolean jj_3R_320() {
39578     if (jj_scan_token(DECLARE)) return true;
39579     if (jj_3R_192()) return true;
39580     return false;
39581   }
39582 
39583   private boolean jj_3R_482() {
39584     if (jj_3R_508()) return true;
39585     Token xsp;
39586     while (true) {
39587       xsp = jj_scanpos;
39588       if (jj_3R_509()) { jj_scanpos = xsp; break; }
39589     }
39590     return false;
39591   }
39592 
39593   private boolean jj_3R_272() {
39594     Token xsp;
39595     xsp = jj_scanpos;
39596     if (jj_3R_320()) jj_scanpos = xsp;
39597     if (jj_scan_token(BEGIN)) return true;
39598     while (true) {
39599       xsp = jj_scanpos;
39600       if (jj_3R_321()) { jj_scanpos = xsp; break; }
39601     }
39602     xsp = jj_scanpos;
39603     if (jj_3R_322()) jj_scanpos = xsp;
39604     if (jj_scan_token(END)) return true;
39605     xsp = jj_scanpos;
39606     if (jj_scan_token(420)) jj_scanpos = xsp;
39607     return false;
39608   }
39609 
39610   private boolean jj_3R_512() {
39611     if (jj_scan_token(IS)) return true;
39612     return false;
39613   }
39614 
39615   private boolean jj_3R_511() {
39616     if (jj_scan_token(13)) return true;
39617     if (jj_scan_token(10)) return true;
39618     return false;
39619   }
39620 
39621   private boolean jj_3R_186() {
39622     Token xsp;
39623     while (true) {
39624       xsp = jj_scanpos;
39625       if (jj_3R_271()) { jj_scanpos = xsp; break; }
39626     }
39627     if (jj_3R_272()) return true;
39628     if (jj_scan_token(4)) return true;
39629     return false;
39630   }
39631 
39632   private boolean jj_3R_510() {
39633     if (jj_scan_token(10)) return true;
39634     return false;
39635   }
39636 
39637   private boolean jj_3R_483() {
39638     Token xsp;
39639     xsp = jj_scanpos;
39640     if (jj_3R_510()) {
39641     jj_scanpos = xsp;
39642     if (jj_3R_511()) {
39643     jj_scanpos = xsp;
39644     if (jj_3R_512()) return true;
39645     }
39646     }
39647     if (jj_3R_482()) return true;
39648     return false;
39649   }
39650 
39651   private boolean jj_3R_113() {
39652     Token xsp;
39653     xsp = jj_scanpos;
39654     if (jj_3R_186()) {
39655     jj_scanpos = xsp;
39656     if (jj_3_15()) return true;
39657     }
39658     return false;
39659   }
39660 
39661   private boolean jj_3R_437() {
39662     if (jj_3R_482()) return true;
39663     Token xsp;
39664     while (true) {
39665       xsp = jj_scanpos;
39666       if (jj_3R_483()) { jj_scanpos = xsp; break; }
39667     }
39668     return false;
39669   }
39670 
39671   private boolean jj_3R_438() {
39672     if (jj_scan_token(AND)) return true;
39673     if (jj_3R_437()) return true;
39674     return false;
39675   }
39676 
39677   private boolean jj_3R_395() {
39678     if (jj_3R_437()) return true;
39679     Token xsp;
39680     while (true) {
39681       xsp = jj_scanpos;
39682       if (jj_3R_438()) { jj_scanpos = xsp; break; }
39683     }
39684     return false;
39685   }
39686 
39687   private boolean jj_3R_396() {
39688     if (jj_scan_token(OR)) return true;
39689     if (jj_3R_395()) return true;
39690     return false;
39691   }
39692 
39693   private boolean jj_3R_344() {
39694     if (jj_3R_395()) return true;
39695     Token xsp;
39696     while (true) {
39697       xsp = jj_scanpos;
39698       if (jj_3R_396()) { jj_scanpos = xsp; break; }
39699     }
39700     return false;
39701   }
39702 
39703   private boolean jj_3R_189() {
39704     if (jj_scan_token(3)) return true;
39705     if (jj_scan_token(ATTACH)) return true;
39706     return false;
39707   }
39708 
39709   private boolean jj_3R_237() {
39710     if (jj_scan_token(3)) return true;
39711     if (jj_3R_234()) return true;
39712     return false;
39713   }
39714 
39715   private boolean jj_3R_235() {
39716     if (jj_scan_token(AT)) return true;
39717     if (jj_scan_token(TIME)) return true;
39718     if (jj_scan_token(ZONE)) return true;
39719     if (jj_3R_133()) return true;
39720     return false;
39721   }
39722 
39723   private boolean jj_3R_140() {
39724     Token xsp;
39725     xsp = jj_scanpos;
39726     if (jj_scan_token(390)) {
39727     jj_scanpos = xsp;
39728     if (jj_scan_token(391)) return true;
39729     }
39730     if (jj_scan_token(5)) return true;
39731     if (jj_3R_234()) return true;
39732     xsp = jj_scanpos;
39733     if (jj_3R_235()) jj_scanpos = xsp;
39734     if (jj_scan_token(AS)) return true;
39735     if (jj_3R_236()) return true;
39736     if (jj_scan_token(7)) return true;
39737     while (true) {
39738       xsp = jj_scanpos;
39739       if (jj_3R_237()) { jj_scanpos = xsp; break; }
39740     }
39741     return false;
39742   }
39743 
39744   private boolean jj_3R_229() {
39745     if (jj_3R_230()) return true;
39746     return false;
39747   }
39748 
39749   private boolean jj_3R_228() {
39750     Token xsp;
39751     xsp = jj_scanpos;
39752     if (jj_scan_token(399)) {
39753     jj_scanpos = xsp;
39754     if (jj_scan_token(400)) {
39755     jj_scanpos = xsp;
39756     if (jj_scan_token(395)) return true;
39757     }
39758     }
39759     return false;
39760   }
39761 
39762   private boolean jj_3R_115() {
39763     Token xsp;
39764     xsp = jj_scanpos;
39765     if (jj_scan_token(2)) {
39766     jj_scanpos = xsp;
39767     if (jj_scan_token(377)) {
39768     jj_scanpos = xsp;
39769     if (jj_scan_token(74)) {
39770     jj_scanpos = xsp;
39771     if (jj_scan_token(78)) {
39772     jj_scanpos = xsp;
39773     if (jj_scan_token(379)) {
39774     jj_scanpos = xsp;
39775     if (jj_scan_token(380)) {
39776     jj_scanpos = xsp;
39777     if (jj_scan_token(381)) {
39778     jj_scanpos = xsp;
39779     if (jj_scan_token(111)) {
39780     jj_scanpos = xsp;
39781     if (jj_scan_token(113)) {
39782     jj_scanpos = xsp;
39783     if (jj_scan_token(382)) {
39784     jj_scanpos = xsp;
39785     if (jj_scan_token(383)) {
39786     jj_scanpos = xsp;
39787     if (jj_scan_token(221)) {
39788     jj_scanpos = xsp;
39789     if (jj_scan_token(384)) {
39790     jj_scanpos = xsp;
39791     if (jj_scan_token(385)) {
39792     jj_scanpos = xsp;
39793     if (jj_scan_token(253)) {
39794     jj_scanpos = xsp;
39795     if (jj_scan_token(294)) {
39796     jj_scanpos = xsp;
39797     if (jj_scan_token(295)) {
39798     jj_scanpos = xsp;
39799     if (jj_scan_token(261)) {
39800     jj_scanpos = xsp;
39801     if (jj_scan_token(386)) {
39802     jj_scanpos = xsp;
39803     if (jj_scan_token(387)) {
39804     jj_scanpos = xsp;
39805     if (jj_scan_token(388)) {
39806     jj_scanpos = xsp;
39807     if (jj_scan_token(75)) {
39808     jj_scanpos = xsp;
39809     if (jj_scan_token(129)) {
39810     jj_scanpos = xsp;
39811     if (jj_scan_token(240)) {
39812     jj_scanpos = xsp;
39813     if (jj_scan_token(99)) {
39814     jj_scanpos = xsp;
39815     if (jj_scan_token(420)) {
39816     jj_scanpos = xsp;
39817     if (jj_3R_189()) return true;
39818     }
39819     }
39820     }
39821     }
39822     }
39823     }
39824     }
39825     }
39826     }
39827     }
39828     }
39829     }
39830     }
39831     }
39832     }
39833     }
39834     }
39835     }
39836     }
39837     }
39838     }
39839     }
39840     }
39841     }
39842     }
39843     }
39844     if (jj_3R_190()) return true;
39845     return false;
39846   }
39847 
39848   private boolean jj_3R_138() {
39849     if (jj_scan_token(TRIM)) return true;
39850     if (jj_scan_token(5)) return true;
39851     Token xsp;
39852     xsp = jj_scanpos;
39853     if (jj_3R_228()) jj_scanpos = xsp;
39854     xsp = jj_scanpos;
39855     if (jj_3R_229()) jj_scanpos = xsp;
39856     if (jj_scan_token(FROM)) return true;
39857     if (jj_3R_230()) return true;
39858     if (jj_scan_token(7)) return true;
39859     return false;
39860   }
39861 
39862   private boolean jj_3R_114() {
39863     if (jj_3R_187()) return true;
39864     if (jj_3R_188()) return true;
39865     return false;
39866   }
39867 
39868   private boolean jj_3_13() {
39869     if (jj_3R_115()) return true;
39870     return false;
39871   }
39872 
39873   private boolean jj_3_12() {
39874     if (jj_3R_114()) return true;
39875     return false;
39876   }
39877 
39878   private boolean jj_3_11() {
39879     if (jj_3R_113()) return true;
39880     return false;
39881   }
39882 
39883   private boolean jj_3_10() {
39884     if (jj_3R_112()) return true;
39885     return false;
39886   }
39887 
39888   private boolean jj_3_9() {
39889     if (jj_3R_111()) return true;
39890     return false;
39891   }
39892 
39893   private boolean jj_3_8() {
39894     if (jj_3R_110()) return true;
39895     return false;
39896   }
39897 
39898   private boolean jj_3_7() {
39899     if (jj_3R_109()) return true;
39900     return false;
39901   }
39902 
39903   private boolean jj_3_6() {
39904     if (jj_3R_108()) return true;
39905     return false;
39906   }
39907 
39908   private boolean jj_3_5() {
39909     if (jj_3R_107()) return true;
39910     return false;
39911   }
39912 
39913   private boolean jj_3_4() {
39914     if (jj_3R_106()) return true;
39915     return false;
39916   }
39917 
39918   private boolean jj_3_3() {
39919     if (jj_3R_105()) return true;
39920     return false;
39921   }
39922 
39923   private boolean jj_3_2() {
39924     if (jj_3R_104()) return true;
39925     return false;
39926   }
39927 
39928   private boolean jj_3_1() {
39929     if (jj_3R_103()) return true;
39930     return false;
39931   }
39932 
39933   private boolean jj_3R_233() {
39934     if (jj_scan_token(ELSE)) return true;
39935     if (jj_3R_234()) return true;
39936     return false;
39937   }
39938 
39939   private boolean jj_3R_232() {
39940     if (jj_scan_token(WHEN)) return true;
39941     if (jj_3R_234()) return true;
39942     if (jj_scan_token(THEN)) return true;
39943     if (jj_3R_234()) return true;
39944     return false;
39945   }
39946 
39947   private boolean jj_3R_231() {
39948     if (jj_3R_234()) return true;
39949     return false;
39950   }
39951 
39952   private boolean jj_3R_139() {
39953     if (jj_scan_token(CASE)) return true;
39954     Token xsp;
39955     xsp = jj_scanpos;
39956     if (jj_3R_231()) jj_scanpos = xsp;
39957     if (jj_3R_232()) return true;
39958     while (true) {
39959       xsp = jj_scanpos;
39960       if (jj_3R_232()) { jj_scanpos = xsp; break; }
39961     }
39962     xsp = jj_scanpos;
39963     if (jj_3R_233()) jj_scanpos = xsp;
39964     if (jj_scan_token(END)) return true;
39965     return false;
39966   }
39967 
39968   private boolean jj_3R_343() {
39969     if (jj_3R_133()) return true;
39970     if (jj_scan_token(9)) return true;
39971     if (jj_scan_token(10)) return true;
39972     if (jj_3R_234()) return true;
39973     return false;
39974   }
39975 
39976   private boolean jj_3R_398() {
39977     if (jj_scan_token(CC_ELSE)) return true;
39978     if (jj_3R_234()) return true;
39979     return false;
39980   }
39981 
39982   private boolean jj_3R_397() {
39983     if (jj_scan_token(CC_ELSIF)) return true;
39984     if (jj_3R_344()) return true;
39985     if (jj_scan_token(CC_THEN)) return true;
39986     if (jj_3R_234()) return true;
39987     return false;
39988   }
39989 
39990   private boolean jj_3R_109() {
39991     if (jj_scan_token(ALTER)) return true;
39992     if (jj_scan_token(TRIGGER)) return true;
39993     if (jj_3R_180()) return true;
39994     if (jj_scan_token(4)) return true;
39995     return false;
39996   }
39997 
39998   private boolean jj_3R_319() {
39999     if (jj_3R_378()) return true;
40000     return false;
40001   }
40002 
40003   private boolean jj_3R_345() {
40004     if (jj_scan_token(CC_IF)) return true;
40005     if (jj_3R_344()) return true;
40006     if (jj_scan_token(CC_THEN)) return true;
40007     if (jj_3R_234()) return true;
40008     Token xsp;
40009     while (true) {
40010       xsp = jj_scanpos;
40011       if (jj_3R_397()) { jj_scanpos = xsp; break; }
40012     }
40013     while (true) {
40014       xsp = jj_scanpos;
40015       if (jj_3R_398()) { jj_scanpos = xsp; break; }
40016     }
40017     if (jj_scan_token(CC_END)) return true;
40018     return false;
40019   }
40020 
40021   private boolean jj_3_45() {
40022     if (jj_3R_133()) return true;
40023     if (jj_scan_token(9)) return true;
40024     if (jj_scan_token(10)) return true;
40025     return false;
40026   }
40027 
40028   private boolean jj_3R_318() {
40029     if (jj_3R_187()) return true;
40030     return false;
40031   }
40032 
40033   private boolean jj_3R_268() {
40034     Token xsp;
40035     xsp = jj_scanpos;
40036     if (jj_3R_318()) {
40037     jj_scanpos = xsp;
40038     if (jj_3R_319()) return true;
40039     }
40040     return false;
40041   }
40042 
40043   private boolean jj_3R_303() {
40044     if (jj_3R_345()) return true;
40045     return false;
40046   }
40047 
40048   private boolean jj_3R_302() {
40049     if (jj_3R_344()) return true;
40050     return false;
40051   }
40052 
40053   private boolean jj_3R_301() {
40054     if (jj_3R_343()) return true;
40055     return false;
40056   }
40057 
40058   private boolean jj_3R_234() {
40059     Token xsp;
40060     xsp = jj_scanpos;
40061     if (jj_3R_301()) {
40062     jj_scanpos = xsp;
40063     if (jj_3R_302()) {
40064     jj_scanpos = xsp;
40065     if (jj_3R_303()) return true;
40066     }
40067     }
40068     return false;
40069   }
40070 
40071   private boolean jj_3R_378() {
40072     Token xsp;
40073     xsp = jj_scanpos;
40074     if (jj_scan_token(361)) {
40075     jj_scanpos = xsp;
40076     if (jj_scan_token(360)) {
40077     jj_scanpos = xsp;
40078     if (jj_scan_token(355)) {
40079     jj_scanpos = xsp;
40080     if (jj_scan_token(354)) {
40081     jj_scanpos = xsp;
40082     if (jj_scan_token(359)) {
40083     jj_scanpos = xsp;
40084     if (jj_scan_token(364)) return true;
40085     }
40086     }
40087     }
40088     }
40089     }
40090     return false;
40091   }
40092 
40093   private boolean jj_3R_274() {
40094     if (jj_scan_token(DISASSOCIATE)) return true;
40095     if (jj_scan_token(STATISTICS)) return true;
40096     return false;
40097   }
40098 
40099   private boolean jj_3_85() {
40100     if (jj_3R_124()) return true;
40101     if (jj_scan_token(3)) return true;
40102     return false;
40103   }
40104 
40105   private boolean jj_3R_273() {
40106     if (jj_scan_token(ASSOCIATE)) return true;
40107     if (jj_scan_token(STATISTICS)) return true;
40108     return false;
40109   }
40110 
40111   private boolean jj_3R_187() {
40112     Token xsp;
40113     xsp = jj_scanpos;
40114     if (jj_scan_token(47)) {
40115     jj_scanpos = xsp;
40116     if (jj_scan_token(344)) {
40117     jj_scanpos = xsp;
40118     if (jj_3R_273()) {
40119     jj_scanpos = xsp;
40120     if (jj_scan_token(346)) {
40121     jj_scanpos = xsp;
40122     if (jj_scan_token(75)) {
40123     jj_scanpos = xsp;
40124     if (jj_scan_token(83)) {
40125     jj_scanpos = xsp;
40126     if (jj_3R_274()) {
40127     jj_scanpos = xsp;
40128     if (jj_scan_token(99)) {
40129     jj_scanpos = xsp;
40130     if (jj_scan_token(129)) {
40131     jj_scanpos = xsp;
40132     if (jj_scan_token(357)) {
40133     jj_scanpos = xsp;
40134     if (jj_scan_token(233)) {
40135     jj_scanpos = xsp;
40136     if (jj_scan_token(240)) {
40137     jj_scanpos = xsp;
40138     if (jj_scan_token(365)) {
40139     jj_scanpos = xsp;
40140     if (jj_scan_token(350)) return true;
40141     }
40142     }
40143     }
40144     }
40145     }
40146     }
40147     }
40148     }
40149     }
40150     }
40151     }
40152     }
40153     }
40154     return false;
40155   }
40156 
40157   private boolean jj_3R_424() {
40158     if (jj_3R_199()) return true;
40159     return false;
40160   }
40161 
40162   private boolean jj_3R_122() {
40163     if (jj_3R_199()) return true;
40164     return false;
40165   }
40166 
40167   private boolean jj_3R_502() {
40168     if (jj_scan_token(IS)) return true;
40169     Token xsp;
40170     while (true) {
40171       xsp = jj_scanpos;
40172       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
40173     }
40174     if (jj_3R_405()) return true;
40175     return false;
40176   }
40177 
40178   private boolean jj_3R_501() {
40179     if (jj_scan_token(RETURN)) return true;
40180     if (jj_3R_236()) return true;
40181     return false;
40182   }
40183 
40184   private boolean jj_3R_500() {
40185     if (jj_3R_386()) return true;
40186     return false;
40187   }
40188 
40189   private boolean jj_3_80() {
40190     if (jj_3R_124()) return true;
40191     if (jj_scan_token(3)) return true;
40192     return false;
40193   }
40194 
40195   private boolean jj_3R_199() {
40196     if (jj_scan_token(CURSOR)) return true;
40197     if (jj_3R_124()) return true;
40198     Token xsp;
40199     xsp = jj_scanpos;
40200     if (jj_3R_500()) jj_scanpos = xsp;
40201     xsp = jj_scanpos;
40202     if (jj_3R_501()) jj_scanpos = xsp;
40203     xsp = jj_scanpos;
40204     if (jj_3R_502()) jj_scanpos = xsp;
40205     if (jj_scan_token(4)) return true;
40206     return false;
40207   }
40208 
40209   private boolean jj_3_84() {
40210     if (jj_3R_122()) return true;
40211     return false;
40212   }
40213 
40214   private boolean jj_3R_270() {
40215     if (jj_3R_268()) return true;
40216     return false;
40217   }
40218 
40219   private boolean jj_3_83() {
40220     if (jj_3R_121()) return true;
40221     return false;
40222   }
40223 
40224   private boolean jj_3_82() {
40225     if (jj_3R_153()) return true;
40226     return false;
40227   }
40228 
40229   private boolean jj_3_81() {
40230     if (jj_3R_119()) return true;
40231     return false;
40232   }
40233 
40234   private boolean jj_3R_177() {
40235     if (jj_3R_268()) return true;
40236     return false;
40237   }
40238 
40239   private boolean jj_3R_563() {
40240     if (jj_3R_183()) return true;
40241     return false;
40242   }
40243 
40244   private boolean jj_3R_633() {
40245     if (jj_3R_183()) return true;
40246     return false;
40247   }
40248 
40249   private boolean jj_3R_152() {
40250     if (jj_scan_token(6)) return true;
40251     if (jj_3R_124()) return true;
40252     return false;
40253   }
40254 
40255   private boolean jj_3R_562() {
40256     if (jj_3R_183()) return true;
40257     return false;
40258   }
40259 
40260   private boolean jj_3R_151() {
40261     if (jj_scan_token(6)) return true;
40262     if (jj_3R_124()) return true;
40263     return false;
40264   }
40265 
40266   private boolean jj_3R_425() {
40267     if (jj_scan_token(IDENTIFIER)) return true;
40268     return false;
40269   }
40270 
40271   private boolean jj_3_76() {
40272     if (jj_3R_124()) return true;
40273     if (jj_scan_token(3)) return true;
40274     return false;
40275   }
40276 
40277   private boolean jj_3_79() {
40278     if (jj_3R_124()) return true;
40279     if (jj_scan_token(3)) return true;
40280     return false;
40281   }
40282 
40283   private boolean jj_3_75() {
40284     if (jj_scan_token(OF)) return true;
40285     if (jj_3R_124()) return true;
40286     Token xsp;
40287     while (true) {
40288       xsp = jj_scanpos;
40289       if (jj_3R_152()) { jj_scanpos = xsp; break; }
40290     }
40291     return false;
40292   }
40293 
40294   private boolean jj_3_74() {
40295     if (jj_scan_token(OF)) return true;
40296     if (jj_3R_124()) return true;
40297     Token xsp;
40298     while (true) {
40299       xsp = jj_scanpos;
40300       if (jj_3R_151()) { jj_scanpos = xsp; break; }
40301     }
40302     return false;
40303   }
40304 
40305   private boolean jj_3R_630() {
40306     if (jj_scan_token(3)) return true;
40307     Token xsp;
40308     xsp = jj_scanpos;
40309     if (jj_scan_token(420)) {
40310     jj_scanpos = xsp;
40311     if (jj_scan_token(428)) {
40312     jj_scanpos = xsp;
40313     if (jj_3R_633()) return true;
40314     }
40315     }
40316     return false;
40317   }
40318 
40319   private boolean jj_3R_599() {
40320     if (jj_scan_token(9)) return true;
40321     if (jj_scan_token(10)) return true;
40322     return false;
40323   }
40324 
40325   private boolean jj_3R_290() {
40326     if (jj_scan_token(PARAMETERS)) return true;
40327     if (jj_3R_564()) return true;
40328     return false;
40329   }
40330 
40331   private boolean jj_3R_566() {
40332     Token xsp;
40333     xsp = jj_scanpos;
40334     if (jj_3R_599()) {
40335     jj_scanpos = xsp;
40336     if (jj_scan_token(92)) return true;
40337     }
40338     if (jj_3R_234()) return true;
40339     return false;
40340   }
40341 
40342   private boolean jj_3R_526() {
40343     if (jj_scan_token(5)) return true;
40344     if (jj_3R_127()) return true;
40345     if (jj_scan_token(7)) return true;
40346     return false;
40347   }
40348 
40349   private boolean jj_3R_289() {
40350     if (jj_scan_token(WITH)) return true;
40351     if (jj_scan_token(CONTEXT)) return true;
40352     return false;
40353   }
40354 
40355   private boolean jj_3R_288() {
40356     if (jj_scan_token(NAME)) return true;
40357     Token xsp;
40358     xsp = jj_scanpos;
40359     if (jj_scan_token(420)) {
40360     jj_scanpos = xsp;
40361     if (jj_scan_token(428)) {
40362     jj_scanpos = xsp;
40363     if (jj_3R_563()) return true;
40364     }
40365     }
40366     return false;
40367   }
40368 
40369   private boolean jj_3R_267() {
40370     Token xsp;
40371     xsp = jj_scanpos;
40372     if (jj_scan_token(100)) {
40373     jj_scanpos = xsp;
40374     if (jj_scan_token(182)) return true;
40375     }
40376     return false;
40377   }
40378 
40379   private boolean jj_3R_528() {
40380     if (jj_scan_token(INDEX)) return true;
40381     if (jj_scan_token(BY)) return true;
40382     if (jj_3R_236()) return true;
40383     return false;
40384   }
40385 
40386   private boolean jj_3R_524() {
40387     if (jj_scan_token(6)) return true;
40388     if (jj_3R_522()) return true;
40389     return false;
40390   }
40391 
40392   private boolean jj_3R_201() {
40393     Token xsp;
40394     xsp = jj_scanpos;
40395     if (jj_3R_287()) {
40396     jj_scanpos = xsp;
40397     if (jj_3R_288()) {
40398     jj_scanpos = xsp;
40399     if (jj_3R_289()) {
40400     jj_scanpos = xsp;
40401     if (jj_3R_290()) return true;
40402     }
40403     }
40404     }
40405     return false;
40406   }
40407 
40408   private boolean jj_3R_287() {
40409     if (jj_scan_token(LIBRARY)) return true;
40410     Token xsp;
40411     xsp = jj_scanpos;
40412     if (jj_scan_token(420)) {
40413     jj_scanpos = xsp;
40414     if (jj_scan_token(428)) {
40415     jj_scanpos = xsp;
40416     if (jj_3R_562()) return true;
40417     }
40418     }
40419     xsp = jj_scanpos;
40420     if (jj_3R_630()) jj_scanpos = xsp;
40421     return false;
40422   }
40423 
40424   private boolean jj_3R_523() {
40425     if (jj_scan_token(6)) return true;
40426     if (jj_3R_522()) return true;
40427     return false;
40428   }
40429 
40430   private boolean jj_3R_269() {
40431     Token xsp;
40432     xsp = jj_scanpos;
40433     if (jj_scan_token(93)) {
40434     jj_scanpos = xsp;
40435     if (jj_scan_token(144)) {
40436     jj_scanpos = xsp;
40437     if (jj_scan_token(297)) return true;
40438     }
40439     }
40440     return false;
40441   }
40442 
40443   private boolean jj_3R_200() {
40444     if (jj_scan_token(LANGUAGE)) return true;
40445     Token xsp;
40446     xsp = jj_scanpos;
40447     if (jj_scan_token(420)) {
40448     jj_scanpos = xsp;
40449     if (jj_scan_token(154)) return true;
40450     }
40451     return false;
40452   }
40453 
40454   private boolean jj_3_77() {
40455     if (jj_3R_124()) return true;
40456     if (jj_scan_token(3)) return true;
40457     return false;
40458   }
40459 
40460   /** Generated Token Manager. */
40461   public PLSQLParserTokenManager token_source;
40462   SimpleCharStream jj_input_stream;
40463   /** Current token. */
40464   public Token token;
40465   /** Next token. */
40466   public Token jj_nt;
40467   private Token jj_scanpos, jj_lastpos;
40468   private int jj_la;
40469   private int jj_gen;
40470   final private int[] jj_la1 = new int[460];
40471   static private int[] jj_la1_0;
40472   static private int[] jj_la1_1;
40473   static private int[] jj_la1_2;
40474   static private int[] jj_la1_3;
40475   static private int[] jj_la1_4;
40476   static private int[] jj_la1_5;
40477   static private int[] jj_la1_6;
40478   static private int[] jj_la1_7;
40479   static private int[] jj_la1_8;
40480   static private int[] jj_la1_9;
40481   static private int[] jj_la1_10;
40482   static private int[] jj_la1_11;
40483   static private int[] jj_la1_12;
40484   static private int[] jj_la1_13;
40485   static {
40486       jj_la1_init_0();
40487       jj_la1_init_1();
40488       jj_la1_init_2();
40489       jj_la1_init_3();
40490       jj_la1_init_4();
40491       jj_la1_init_5();
40492       jj_la1_init_6();
40493       jj_la1_init_7();
40494       jj_la1_init_8();
40495       jj_la1_init_9();
40496       jj_la1_init_10();
40497       jj_la1_init_11();
40498       jj_la1_init_12();
40499       jj_la1_init_13();
40500    }
40501    private static void jj_la1_init_0() {
40502       jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x0,0x20,0x0,0x0,0x0,0x40,0x0,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
40503    }
40504    private static void jj_la1_init_1() {
40505       jj_la1_1 = new int[] {0x2008000,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x30,0x800000,0x80000,0xfdfffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x80000,0x52e43c38,0x0,0x2000000,0xfdfffff8,0x80000,0x0,0x0,0xfdfffff8,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x800000,0x30,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2000,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x882000,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x10000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000,0x4000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x80000,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x50e43ff8,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x30,0x800000,0x80000,0x80000,0x0,0x0,0x0,0x80000,0x0,0x80000,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x400000,0x1000,0x30,0x800000,0x80000,0xfdfffff8,0x0,0xfdfffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x8000,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x52e43c38,0x0,0x0,0xfdfffff8,0x0,0x0,0xfdfffff8,0x0,0x8000,0x0,0x8000,0xfdfffff8,0x8000,0x0,0x8000,0x841bc000,0x40e03c30,0xfdfffff8,0x50e43c38,0x79e43ff8,0x28840000,0x0,};
40506    }
40507    private static void jj_la1_init_2() {
40508       jj_la1_2 = new int[] {0x24085c00,0x20001000,0x20001000,0x0,0x4c00,0x0,0x4000000,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x0,0x490000,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x80000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x80,0x7fffffff,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x80000000,0x0,0x0,0xbd71f5b,0x10000000,0x10000000,0x90000,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x0,0x8,0x1,0x8,0x0,0x9000018,0x0,0x0,0x8,0x1,0x0,0x0,0x1000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x0,0x20001000,0x0,0x7d71f47,0x27d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x27d71f47,0x27d71f47,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x3d71f47,0x2d71f43,0x0,0x2d71f43,0x0,0x2d71f43,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbd71f5b,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x3d71f47,0x0,0x1000000,0x2d71f43,0x0,0x3d71f47,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2d71f43,0x2d75f43,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x7fffffff,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0x0,0x2,0x2,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x20000000,0x0,0x20080800,0x0,0x20000000,0x0,0x20080800,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x480000,0x7fffffff,0x0,0x80800,0x0,0x80800,0x7fffffff,0x80800,0x0,0x80800,0x790860a8,0x2d71f43,0x7fffffff,0x2d71f43,0x2bf79f5b,0x9200008,0x0,};
40509    }
40510    private static void jj_la1_init_3() {
40511       jj_la1_3 = new int[] {0x20028008,0x0,0x0,0x0,0x28008,0x0,0x0,0xeefead31,0x1000,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0xeefead31,0x1000,0x0,0xfffffdff,0x0,0x0,0x20800000,0xfffffdff,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x20800000,0x0,0x0,0x0,0x20000000,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0xeefead31,0x0,0x8000,0x0,0xeefead31,0xeefead31,0x0,0x68be2d31,0x0,0x40,0x0,0xeefead31,0xeefead31,0xeefead31,0xeefead31,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x80,0x40,0x0,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x68be2d31,0x0,0x40,0x0,0x400,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x800,0x2,0x2,0x10000000,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x68be2d31,0x0,0x200000,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0xfffffdff,0x0,0x800000,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x800020,0x800020,0x0,0x0,0x0,0x800000,0x800000,0x8,0x0,0x0,0x0,0xfffffdff,0x0,0xfffffdff,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8000000,0x8002000,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x2000000,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101,0x101,0x0,0x0,0x0,0x0,0xeefead31,0x0,0x0,0xfffffdff,0x0,0x20000000,0xfffffdff,0x0,0x8,0x0,0x8,0xfffffdff,0x8,0x0,0x8,0x1301404a,0x68be2d31,0xfffffdff,0x68be2d31,0x6dbfadb5,0x1000000,0x0,};
40512    }
40513    private static void jj_la1_init_4() {
40514       jj_la1_4 = new int[] {0x80010002,0x80010000,0x80010000,0x0,0x2,0x0,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x1000000,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x1000000,0x0,0x20000,0xffffdbbd,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x1000000,0x200,0x200,0x2ea6d134,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x20,0x20,0x0,0x20,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0x0,0x80010000,0x0,0x2ea2d1b4,0xaea3d1b4,0x0,0x2ea2d134,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x1000,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x600,0x600,0x0,0x600,0x600,0x0,0x0,0x0,0x0,0x20000000,0x0,0x400000,0x0,0x200,0x200,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x2ea6d134,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x2ea2d134,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x10000200,0x100000,0x0,0x0,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x2ea2d134,0x0,0x200000,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x2eaad134,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x4000,0x4000,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x0,0x0,0x1000000,0x0,0x1000000,0x0,0xffffdbbd,0xffffdbbd,0x0,0x20000,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20020000,0x20020000,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x0,0xffffdbbd,0x0,0x20000,0x0,0x20000,0x2000,0x0,0x2000,0x0,0x0,0x800000,0x800000,0xffffdbbd,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x10002,0x0,0x10000,0x0,0x10002,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x0,0x0,0xffffdbbd,0x0,0x2,0x0,0x2,0xffffdbbd,0x2,0x0,0x2,0x91550a4b,0x2ea2d134,0xffffdbbd,0x2ea2d134,0x2eaed134,0x240020,0x0,};
40515    }
40516    private static void jj_la1_init_5() {
40517       jj_la1_5 = new int[] {0x20,0x20,0x20,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0x800014,0xffedffff,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x0,0x0,0xfc49ef7f,0x0,0x0,0x800014,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf800c001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2100,0x2100,0x0,0x2100,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x20,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x4496f7e,0x0,0x4496f7e,0x0,0x4496f7e,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x800000,0x0,0xf0000000,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0xfc49ef7f,0x0,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x64b6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x800000,0x10,0x0,0x10,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x0,0x0,0x800,0x800,0x0,0x6cb6f7e,0x6cb6f7e,0x800000,0x64b6f7e,0x800000,0x0,0x0,0x0,0x0,0x64b6f7e,0x6496f7e,0x64b6f7e,0x0,0x2000000,0x4496f7e,0x0,0x6cb6f7e,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2800000,0x0,0x80000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x4,0x4,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0xffedffff,0x0,0x800014,0x0,0x0,0x2800000,0x800000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x400,0x0,0x0,0x0,0x800014,0x800014,0x0,0x0,0x0,0x800014,0x800014,0x400,0x0,0x0,0x0,0xffedffff,0x0,0xffedffff,0x0,0x2800000,0x800000,0x2000000,0x800000,0x800000,0x800000,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x10000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0xb901081,0x449677c,0xffedffff,0x4496f7e,0xfc6def7f,0xf800e201,0x0,};
40518    }
40519    private static void jj_la1_init_6() {
40520       jj_la1_6 = new int[] {0xa0020000,0x0,0x0,0x0,0x20000000,0x0,0x0,0xcc2b6392,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x800,0x0,0x0,0x0,0x20000,0x0,0xcc2b6392,0x0,0x0,0xfb9bffbf,0x0,0x4000000,0x80011000,0xff9bffbf,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x800,0x0,0x0,0x0,0x440000,0x0,0x0,0x0,0x0,0x0,0x1000,0xfb9bffbf,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x440000,0x0,0x0,0x4000000,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x440000,0x8000,0x0,0xcb8b6393,0x0,0x0,0x80011000,0x0,0x0,0x0,0x80000000,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0x0,0xc80b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x8000,0x8000,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcb8b6393,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x40,0x0,0x40,0xc80b6392,0xc80b6392,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x1000,0x0,0x1000,0x80020000,0x80020000,0x0,0x80020000,0x80020000,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x800,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x200,0x200,0x0,0x10000,0x0,0x10000,0x1000,0x1000,0x0,0x0,0x40000,0x400000,0x0,0x0,0x0,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff9bffbf,0xff9bffbf,0x0,0x11000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0x0,0xff9bffbf,0x4000000,0x80000000,0xfb9bffbf,0x0,0x0,0x800,0x0,0xfb9bffbf,0x0,0x0,0x0,0x10101c28,0x880b6192,0xfb9bffbf,0xc80b6392,0xff8be397,0x3800005,0x0,};
40521    }
40522    private static void jj_la1_init_7() {
40523       jj_la1_7 = new int[] {0x25030200,0x5020000,0x5020000,0x0,0x20010000,0x0,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x1000,0x0,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x1000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100008,0x100058,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x25020000,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x2fbeebfc,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x0,0x8000,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x2fbeebfc,0x800000,0x2fbeebfc,0x2bbeebfc,0x0,0x2bbeebfc,0x0,0x2bbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x6000,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x4,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x2fbeebfc,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x2bbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x2bbeebfc,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x2bbeebfc,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10200,0x0,0x0,0x0,0x10200,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0xbffeebff,0x0,0x10200,0x0,0x10200,0xbffeebff,0x10200,0x0,0x10200,0xe4010409,0x2bbeebf4,0xbffeebff,0x2bbeebfc,0x3bfeebfe,0x22740078,0x0,};
40524    }
40525    private static void jj_la1_init_8() {
40526       jj_la1_8 = new int[] {0x14000020,0x0,0x0,0x0,0x20,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x40,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675f,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x5afd675e,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x4001,0xc0000,0x0,0x0,0x0,0x0,0x1000000,0x80000,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x5afde75f,0x10000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x10000000,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x8080000,0x5afd675e,0x0,0x5afd675e,0x40000,0x0,0x8080000,0x8000000,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x14000000,0x14000000,0x0,0x14000000,0x14000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x7fffffff,0x7fffffff,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x85029021,0x4afd4742,0x7fffffff,0x5afd675e,0x7efd7fdb,0xfc8001,0x0,};
40527    }
40528    private static void jj_la1_init_9() {
40529       jj_la1_9 = new int[] {0x400002c0,0x40000200,0x40000200,0x0,0xc0,0x0,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0x0,0xffffff71,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xffffff71,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0xc3c0c00,0xf3fbc00,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x10000000,0x10000000,0x20000000,0x10000000,0x40000000,0x40000000,0x0,0xfffdf371,0xfffdf371,0x4,0x40000200,0x0,0xfffdf171,0xfffdf371,0x0,0xfffdf161,0x4,0x0,0x0,0xfffdf371,0xfffdf371,0xfffdf371,0xfffdf371,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x2,0x0,0xfffdf163,0x0,0xfffdf161,0xbffdf161,0x4,0xbffdf161,0x4,0xbffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0xfffdf161,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0xfffdf161,0x0,0x0,0xbffdf161,0x0,0xfffdf161,0x20000000,0x0,0x0,0x0,0x100,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x1,0xffffff71,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0xbffdf161,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x40000e0a,0xbfed7161,0xffffff71,0xbffdf161,0xbffffd71,0xff7ffc00,0x0,};
40530    }
40531    private static void jj_la1_init_10() {
40532       jj_la1_10 = new int[] {0xc7000000,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0xff0000c7,0x0,0x0,0x400,0xff0004c7,0xff0084c7,0xff0084c7,0x2000,0xff0084c7,0xff0084c7,0x1000,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0xff0000c7,0x2000,0x1000,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0xff0004c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0xff0004c7,0xff0000c7,0x0,0xff0000c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x2000,0xff0084c7,0x1000,0xff0084c7,0x8400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x2000,0x1000,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0xff0000c7,0x0,0x0,0xff0000c7,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0xc7000000,0x0,0x0,0x0,0xc7000000,0x10000000,0xff0000c7,0xc0,0xc0,0x20,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0xe,0x0,0xff0084c7,0xe,0x0,0xff0000cf,0xe,0x0,0xff0000c7,0x6,0xc7000000,0x0,0xc7000000,0xff0000c7,0xc7000000,0x0,0xc7000000,0x300,0xff0000c7,0xff0000c7,0xff0000c7,0xff0000c7,0x1,0x0,};
40533    }
40534    private static void jj_la1_init_11() {
40535       jj_la1_11 = new int[] {0xfa002020,0x0,0x0,0x0,0xfa000000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000000,0x0,0xffffffff,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x4000,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x4004000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33ac,0x0,0x0,0x0,0x33ac,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x401,0xffffffff,0x0,0x401,0xffffffff,0x0,0x0,0xffffffff,0x0,0x33ac,0x0,0x33ac,0xffffffff,0x2020,0x138c,0x33ac,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x4000000,0x0,};
40536    }
40537    private static void jj_la1_init_12() {
40538       jj_la1_12 = new int[] {0x1f,0x0,0x0,0x0,0x1f,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x18800,0x18800,0x1fc7ffff,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x1fc7ffff,0x0,0x0,0x60000,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x100000,0x100000,0x300000,0x80000,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,};
40539    }
40540    private static void jj_la1_init_13() {
40541       jj_la1_13 = new int[] {0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x1630,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x0,0x10,0x1f010,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x10,0x1630,0x1630,0x1630,0x1630,0x10,0x0,0x0,0x1630,0x10,0x1630,0x10,0x1630,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x1010,0x0,0x1010,0x0,0x1010,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x1410,0x1410,0x0,0x1410,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1630,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x1630,0x0,0x620,0x1010,0x0,0x1630,0x0,0x0,0x620,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1410,0x1410,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x10,0x1f010,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1010,0x1010,0x1e000,0xe000,};
40542    }
40543   final private JJCalls[] jj_2_rtns = new JJCalls[85];
40544   private boolean jj_rescan = false;
40545   private int jj_gc = 0;
40546 
40547   /** Constructor with InputStream. */
40548   public PLSQLParser(java.io.InputStream stream) {
40549      this(stream, null);
40550   }
40551   /** Constructor with InputStream and supplied encoding */
40552   public PLSQLParser(java.io.InputStream stream, String encoding) {
40553     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40554     token_source = new PLSQLParserTokenManager(jj_input_stream);
40555     token = new Token();
40556     token.next = jj_nt = token_source.getNextToken();
40557     jj_gen = 0;
40558     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40559     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40560   }
40561 
40562   /** Reinitialise. */
40563   public void ReInit(java.io.InputStream stream) {
40564      ReInit(stream, null);
40565   }
40566   /** Reinitialise. */
40567   public void ReInit(java.io.InputStream stream, String encoding) {
40568     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40569     token_source.ReInit(jj_input_stream);
40570     token = new Token();
40571     token.next = jj_nt = token_source.getNextToken();
40572     jjtree.reset();
40573     jj_gen = 0;
40574     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40575     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40576   }
40577 
40578   /** Constructor. */
40579   public PLSQLParser(java.io.Reader stream) {
40580     jj_input_stream = new SimpleCharStream(stream, 1, 1);
40581     token_source = new PLSQLParserTokenManager(jj_input_stream);
40582     token = new Token();
40583     token.next = jj_nt = token_source.getNextToken();
40584     jj_gen = 0;
40585     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40586     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40587   }
40588 
40589   /** Reinitialise. */
40590   public void ReInit(java.io.Reader stream) {
40591     jj_input_stream.ReInit(stream, 1, 1);
40592     token_source.ReInit(jj_input_stream);
40593     token = new Token();
40594     token.next = jj_nt = token_source.getNextToken();
40595     jjtree.reset();
40596     jj_gen = 0;
40597     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40598     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40599   }
40600 
40601   /** Constructor with generated Token Manager. */
40602   public PLSQLParser(PLSQLParserTokenManager tm) {
40603     token_source = tm;
40604     token = new Token();
40605     token.next = jj_nt = token_source.getNextToken();
40606     jj_gen = 0;
40607     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40608     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40609   }
40610 
40611   /** Reinitialise. */
40612   public void ReInit(PLSQLParserTokenManager tm) {
40613     token_source = tm;
40614     token = new Token();
40615     token.next = jj_nt = token_source.getNextToken();
40616     jjtree.reset();
40617     jj_gen = 0;
40618     for (int i = 0; i < 460; i++) jj_la1[i] = -1;
40619     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40620   }
40621 
40622   private Token jj_consume_token(int kind) throws ParseException {
40623     Token oldToken = token;
40624     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40625     else jj_nt = jj_nt.next = token_source.getNextToken();
40626     if (token.kind == kind) {
40627       jj_gen++;
40628       if (++jj_gc > 100) {
40629         jj_gc = 0;
40630         for (int i = 0; i < jj_2_rtns.length; i++) {
40631           JJCalls c = jj_2_rtns[i];
40632           while (c != null) {
40633             if (c.gen < jj_gen) c.first = null;
40634             c = c.next;
40635           }
40636         }
40637       }
40638       return token;
40639     }
40640     jj_nt = token;
40641     token = oldToken;
40642     jj_kind = kind;
40643     throw generateParseException();
40644   }
40645 
40646   static private final class LookaheadSuccess extends java.lang.Error { }
40647   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
40648   private boolean jj_scan_token(int kind) {
40649     if (jj_scanpos == jj_lastpos) {
40650       jj_la--;
40651       if (jj_scanpos.next == null) {
40652         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
40653       } else {
40654         jj_lastpos = jj_scanpos = jj_scanpos.next;
40655       }
40656     } else {
40657       jj_scanpos = jj_scanpos.next;
40658     }
40659     if (jj_rescan) {
40660       int i = 0; Token tok = token;
40661       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
40662       if (tok != null) jj_add_error_token(kind, i);
40663     }
40664     if (jj_scanpos.kind != kind) return true;
40665     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
40666     return false;
40667   }
40668 
40669 
40670 /** Get the next Token. */
40671   final public Token getNextToken() {
40672     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40673     else jj_nt = jj_nt.next = token_source.getNextToken();
40674     jj_gen++;
40675     return token;
40676   }
40677 
40678 /** Get the specific Token. */
40679   final public Token getToken(int index) {
40680     Token t = token;
40681     for (int i = 0; i < index; i++) {
40682       if (t.next != null) t = t.next;
40683       else t = t.next = token_source.getNextToken();
40684     }
40685     return t;
40686   }
40687 
40688   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
40689   private int[] jj_expentry;
40690   private int jj_kind = -1;
40691   private int[] jj_lasttokens = new int[100];
40692   private int jj_endpos;
40693 
40694   private void jj_add_error_token(int kind, int pos) {
40695     if (pos >= 100) return;
40696     if (pos == jj_endpos + 1) {
40697       jj_lasttokens[jj_endpos++] = kind;
40698     } else if (jj_endpos != 0) {
40699       jj_expentry = new int[jj_endpos];
40700       for (int i = 0; i < jj_endpos; i++) {
40701         jj_expentry[i] = jj_lasttokens[i];
40702       }
40703       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
40704         int[] oldentry = (int[])(it.next());
40705         if (oldentry.length == jj_expentry.length) {
40706           for (int i = 0; i < jj_expentry.length; i++) {
40707             if (oldentry[i] != jj_expentry[i]) {
40708               continue jj_entries_loop;
40709             }
40710           }
40711           jj_expentries.add(jj_expentry);
40712           break jj_entries_loop;
40713         }
40714       }
40715       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
40716     }
40717   }
40718 
40719   /** Generate ParseException. */
40720   public ParseException generateParseException() {
40721     jj_expentries.clear();
40722     boolean[] la1tokens = new boolean[434];
40723     if (jj_kind >= 0) {
40724       la1tokens[jj_kind] = true;
40725       jj_kind = -1;
40726     }
40727     for (int i = 0; i < 460; i++) {
40728       if (jj_la1[i] == jj_gen) {
40729         for (int j = 0; j < 32; j++) {
40730           if ((jj_la1_0[i] & (1<<j)) != 0) {
40731             la1tokens[j] = true;
40732           }
40733           if ((jj_la1_1[i] & (1<<j)) != 0) {
40734             la1tokens[32+j] = true;
40735           }
40736           if ((jj_la1_2[i] & (1<<j)) != 0) {
40737             la1tokens[64+j] = true;
40738           }
40739           if ((jj_la1_3[i] & (1<<j)) != 0) {
40740             la1tokens[96+j] = true;
40741           }
40742           if ((jj_la1_4[i] & (1<<j)) != 0) {
40743             la1tokens[128+j] = true;
40744           }
40745           if ((jj_la1_5[i] & (1<<j)) != 0) {
40746             la1tokens[160+j] = true;
40747           }
40748           if ((jj_la1_6[i] & (1<<j)) != 0) {
40749             la1tokens[192+j] = true;
40750           }
40751           if ((jj_la1_7[i] & (1<<j)) != 0) {
40752             la1tokens[224+j] = true;
40753           }
40754           if ((jj_la1_8[i] & (1<<j)) != 0) {
40755             la1tokens[256+j] = true;
40756           }
40757           if ((jj_la1_9[i] & (1<<j)) != 0) {
40758             la1tokens[288+j] = true;
40759           }
40760           if ((jj_la1_10[i] & (1<<j)) != 0) {
40761             la1tokens[320+j] = true;
40762           }
40763           if ((jj_la1_11[i] & (1<<j)) != 0) {
40764             la1tokens[352+j] = true;
40765           }
40766           if ((jj_la1_12[i] & (1<<j)) != 0) {
40767             la1tokens[384+j] = true;
40768           }
40769           if ((jj_la1_13[i] & (1<<j)) != 0) {
40770             la1tokens[416+j] = true;
40771           }
40772         }
40773       }
40774     }
40775     for (int i = 0; i < 434; i++) {
40776       if (la1tokens[i]) {
40777         jj_expentry = new int[1];
40778         jj_expentry[0] = i;
40779         jj_expentries.add(jj_expentry);
40780       }
40781     }
40782     jj_endpos = 0;
40783     jj_rescan_token();
40784     jj_add_error_token(0, 0);
40785     int[][] exptokseq = new int[jj_expentries.size()][];
40786     for (int i = 0; i < jj_expentries.size(); i++) {
40787       exptokseq[i] = jj_expentries.get(i);
40788     }
40789     return new ParseException(token, exptokseq, tokenImage);
40790   }
40791 
40792   /** Enable tracing. */
40793   final public void enable_tracing() {
40794   }
40795 
40796   /** Disable tracing. */
40797   final public void disable_tracing() {
40798   }
40799 
40800   private void jj_rescan_token() {
40801     jj_rescan = true;
40802     for (int i = 0; i < 85; i++) {
40803     try {
40804       JJCalls p = jj_2_rtns[i];
40805       do {
40806         if (p.gen > jj_gen) {
40807           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
40808           switch (i) {
40809             case 0: jj_3_1(); break;
40810             case 1: jj_3_2(); break;
40811             case 2: jj_3_3(); break;
40812             case 3: jj_3_4(); break;
40813             case 4: jj_3_5(); break;
40814             case 5: jj_3_6(); break;
40815             case 6: jj_3_7(); break;
40816             case 7: jj_3_8(); break;
40817             case 8: jj_3_9(); break;
40818             case 9: jj_3_10(); break;
40819             case 10: jj_3_11(); break;
40820             case 11: jj_3_12(); break;
40821             case 12: jj_3_13(); break;
40822             case 13: jj_3_14(); break;
40823             case 14: jj_3_15(); break;
40824             case 15: jj_3_16(); break;
40825             case 16: jj_3_17(); break;
40826             case 17: jj_3_18(); break;
40827             case 18: jj_3_19(); break;
40828             case 19: jj_3_20(); break;
40829             case 20: jj_3_21(); break;
40830             case 21: jj_3_22(); break;
40831             case 22: jj_3_23(); break;
40832             case 23: jj_3_24(); break;
40833             case 24: jj_3_25(); break;
40834             case 25: jj_3_26(); break;
40835             case 26: jj_3_27(); break;
40836             case 27: jj_3_28(); break;
40837             case 28: jj_3_29(); break;
40838             case 29: jj_3_30(); break;
40839             case 30: jj_3_31(); break;
40840             case 31: jj_3_32(); break;
40841             case 32: jj_3_33(); break;
40842             case 33: jj_3_34(); break;
40843             case 34: jj_3_35(); break;
40844             case 35: jj_3_36(); break;
40845             case 36: jj_3_37(); break;
40846             case 37: jj_3_38(); break;
40847             case 38: jj_3_39(); break;
40848             case 39: jj_3_40(); break;
40849             case 40: jj_3_41(); break;
40850             case 41: jj_3_42(); break;
40851             case 42: jj_3_43(); break;
40852             case 43: jj_3_44(); break;
40853             case 44: jj_3_45(); break;
40854             case 45: jj_3_46(); break;
40855             case 46: jj_3_47(); break;
40856             case 47: jj_3_48(); break;
40857             case 48: jj_3_49(); break;
40858             case 49: jj_3_50(); break;
40859             case 50: jj_3_51(); break;
40860             case 51: jj_3_52(); break;
40861             case 52: jj_3_53(); break;
40862             case 53: jj_3_54(); break;
40863             case 54: jj_3_55(); break;
40864             case 55: jj_3_56(); break;
40865             case 56: jj_3_57(); break;
40866             case 57: jj_3_58(); break;
40867             case 58: jj_3_59(); break;
40868             case 59: jj_3_60(); break;
40869             case 60: jj_3_61(); break;
40870             case 61: jj_3_62(); break;
40871             case 62: jj_3_63(); break;
40872             case 63: jj_3_64(); break;
40873             case 64: jj_3_65(); break;
40874             case 65: jj_3_66(); break;
40875             case 66: jj_3_67(); break;
40876             case 67: jj_3_68(); break;
40877             case 68: jj_3_69(); break;
40878             case 69: jj_3_70(); break;
40879             case 70: jj_3_71(); break;
40880             case 71: jj_3_72(); break;
40881             case 72: jj_3_73(); break;
40882             case 73: jj_3_74(); break;
40883             case 74: jj_3_75(); break;
40884             case 75: jj_3_76(); break;
40885             case 76: jj_3_77(); break;
40886             case 77: jj_3_78(); break;
40887             case 78: jj_3_79(); break;
40888             case 79: jj_3_80(); break;
40889             case 80: jj_3_81(); break;
40890             case 81: jj_3_82(); break;
40891             case 82: jj_3_83(); break;
40892             case 83: jj_3_84(); break;
40893             case 84: jj_3_85(); break;
40894           }
40895         }
40896         p = p.next;
40897       } while (p != null);
40898       } catch(LookaheadSuccess ls) { }
40899     }
40900     jj_rescan = false;
40901   }
40902 
40903   private void jj_save(int index, int xla) {
40904     JJCalls p = jj_2_rtns[index];
40905     while (p.gen > jj_gen) {
40906       if (p.next == null) { p = p.next = new JJCalls(); break; }
40907       p = p.next;
40908     }
40909     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
40910   }
40911 
40912   static final class JJCalls {
40913     int gen;
40914     Token first;
40915     int arg;
40916     JJCalls next;
40917   }
40918 
40919 }